diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/AbstractCompilerBasedTestForFir.kt b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/AbstractCompilerBasedTestForFir.kt index fb0a9dacca0..edb37edd48e 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/AbstractCompilerBasedTestForFir.kt +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/AbstractCompilerBasedTestForFir.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2021 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. */ @@ -9,8 +9,8 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirResolveSessionService import org.jetbrains.kotlin.analysis.low.level.api.fir.api.DiagnosticCheckerFilter import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirFile +import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostic.compiler.based.facades.LLFirAnalyzerFacadeFactory import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.FirLowLevelCompilerBasedTestConfigurator -import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer import org.jetbrains.kotlin.analysis.test.framework.AbstractCompilerBasedTest import org.jetbrains.kotlin.analysis.test.framework.base.registerAnalysisApiBaseTestServices import org.jetbrains.kotlin.analysis.test.framework.project.structure.KtSourceModuleByCompilerConfiguration @@ -31,7 +31,9 @@ import org.jetbrains.kotlin.test.frontend.fir.FirOutputPartForDependsOnModule import org.jetbrains.kotlin.test.model.DependencyKind 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.ServiceRegistrationData +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.isKtFile abstract class AbstractCompilerBasedTestForFir : AbstractCompilerBasedTest() { final override fun TestConfigurationBuilder.configuration() { @@ -63,7 +65,8 @@ abstract class AbstractCompilerBasedTestForFir : AbstractCompilerBasedTest() { open fun TestConfigurationBuilder.configureTest() {} inner class LowLevelFirFrontendFacade( - testServices: TestServices + testServices: TestServices, + private val facadeFactory: LLFirAnalyzerFacadeFactory, ) : FirFrontendFacade(testServices) { override val additionalServices: List get() = emptyList() @@ -99,7 +102,7 @@ abstract class AbstractCompilerBasedTestForFir : AbstractCompilerBasedTest() { DiagnosticCheckerFilter.EXTENDED_AND_COMMON_CHECKERS } else DiagnosticCheckerFilter.ONLY_COMMON_CHECKERS - val analyzerFacade = LowLevelFirAnalyzerFacade(firResolveSession, allFirFiles.toMap(), diagnosticCheckerFilter) + val analyzerFacade = facadeFactory.createFirFacade(firResolveSession, allFirFiles.toMap(), diagnosticCheckerFilter) return FirOutputPartForDependsOnModule( module, firResolveSession.useSiteFirSession, @@ -115,12 +118,7 @@ abstract class AbstractCompilerBasedTestForFir : AbstractCompilerBasedTest() { if (ignoreTest(filePath, configuration)) { return } - val oldEnableDeepEnsure = LLFirLazyTransformer.needCheckingIfClassMembersAreResolved - try { - LLFirLazyTransformer.needCheckingIfClassMembersAreResolved = true - super.runTest(filePath) - } finally { - LLFirLazyTransformer.needCheckingIfClassMembersAreResolved = oldEnableDeepEnsure - } + + super.runTest(filePath) } -} +} \ No newline at end of file diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/LowLevelFirAnalyzerFacade.kt b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/LowLevelFirAnalyzerFacade.kt index 2d914c2a3d2..9fbb5932bea 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/LowLevelFirAnalyzerFacade.kt +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/LowLevelFirAnalyzerFacade.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2021 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. */ @@ -10,14 +10,17 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDiagnosticsForFile import org.jetbrains.kotlin.diagnostics.KtDiagnostic import org.jetbrains.kotlin.fir.AbstractFirAnalyzerFacade -import org.jetbrains.kotlin.fir.backend.* +import org.jetbrains.kotlin.fir.backend.Fir2IrCommonMemberStorage +import org.jetbrains.kotlin.fir.backend.Fir2IrExtensions +import org.jetbrains.kotlin.fir.backend.Fir2IrResult +import org.jetbrains.kotlin.fir.backend.IrBuiltInsOverFir import org.jetbrains.kotlin.fir.declarations.FirFile import org.jetbrains.kotlin.fir.psi import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.test.model.TestFile -class LowLevelFirAnalyzerFacade( +open class LowLevelFirAnalyzerFacade( val firResolveSession: LLFirResolveSession, val allFirFiles: Map, private val diagnosticCheckerFilter: DiagnosticCheckerFilter, @@ -25,7 +28,14 @@ class LowLevelFirAnalyzerFacade( override val scopeSession: ScopeSession get() = ScopeSession() + private var resolved: Boolean = false + override fun runCheckers(): Map> { + if (!resolved) { + runResolution() + resolved = true + } + return allFirFiles.values.associateWith { firFile -> val ktFile = firFile.psi as KtFile val diagnostics = ktFile.collectDiagnosticsForFile(firResolveSession, diagnosticCheckerFilter) @@ -34,7 +44,8 @@ class LowLevelFirAnalyzerFacade( } } - override fun runResolution(): List = shouldNotBeCalled() + override fun runResolution(): List = allFirFiles.values.toList() + override fun convertToIr( fir2IrExtensions: Fir2IrExtensions, commonMemberStorage: Fir2IrCommonMemberStorage, diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/AbstractDiagnosisCompilerTestDataTest.kt b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/AbstractDiagnosticCompilerTestDataTest.kt similarity index 60% rename from analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/AbstractDiagnosisCompilerTestDataTest.kt rename to analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/AbstractDiagnosticCompilerTestDataTest.kt index feadc9b54b1..3bba3e01f1e 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/AbstractDiagnosisCompilerTestDataTest.kt +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/AbstractDiagnosticCompilerTestDataTest.kt @@ -1,16 +1,18 @@ /* - * Copyright 2010-2021 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.analysis.low.level.api.fir.diagnostic.compiler.based import org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based.AbstractCompilerBasedTestForFir +import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostic.compiler.based.facades.LLFirAnalyzerFacadeFactoryWithoutPreresolve +import org.jetbrains.kotlin.test.bind import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder import org.jetbrains.kotlin.test.runners.baseFirDiagnosticTestConfiguration -abstract class AbstractDiagnosisCompilerTestDataTest : AbstractCompilerBasedTestForFir() { +abstract class AbstractDiagnosticCompilerTestDataTest : AbstractCompilerBasedTestForFir() { override fun TestConfigurationBuilder.configureTest() { - baseFirDiagnosticTestConfiguration(frontendFacade = ::LowLevelFirFrontendFacade) + baseFirDiagnosticTestConfiguration(frontendFacade = ::LowLevelFirFrontendFacade.bind(LLFirAnalyzerFacadeFactoryWithoutPreresolve)) } } diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/AbstractLLFirDiagnosisCompilerTestDataSpecTest.kt b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/AbstractLLFirDiagnosticCompilerTestDataSpecTest.kt similarity index 53% rename from analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/AbstractLLFirDiagnosisCompilerTestDataSpecTest.kt rename to analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/AbstractLLFirDiagnosticCompilerTestDataSpecTest.kt index 675854358e8..8bef53d22e6 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/AbstractLLFirDiagnosisCompilerTestDataSpecTest.kt +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/AbstractLLFirDiagnosticCompilerTestDataSpecTest.kt @@ -1,18 +1,24 @@ /* - * Copyright 2010-2021 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.analysis.low.level.api.fir.diagnostic.compiler.based import org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based.AbstractCompilerBasedTestForFir +import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostic.compiler.based.facades.LLFirAnalyzerFacadeFactoryWithoutPreresolve +import org.jetbrains.kotlin.test.bind import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder import org.jetbrains.kotlin.test.runners.baseFirDiagnosticTestConfiguration import org.jetbrains.kotlin.test.runners.baseFirSpecDiagnosticTestConfiguration -abstract class AbstractLLFirDiagnosisCompilerTestDataSpecTest : AbstractCompilerBasedTestForFir() { +abstract class AbstractLLFirDiagnosticCompilerTestDataSpecTest : AbstractCompilerBasedTestForFir() { override fun TestConfigurationBuilder.configureTest() { - baseFirDiagnosticTestConfiguration(frontendFacade = ::LowLevelFirFrontendFacade) - baseFirSpecDiagnosticTestConfiguration() + baseFirDiagnosticTestConfiguration(frontendFacade = ::LowLevelFirFrontendFacade.bind(LLFirAnalyzerFacadeFactoryWithoutPreresolve)) + baseFirSpecDiagnosticTestConfigurationForIde() } } + +fun TestConfigurationBuilder.baseFirSpecDiagnosticTestConfigurationForIde() { + baseFirSpecDiagnosticTestConfiguration() +} diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/AbstractLLFirPreresolvedReversedDiagnosticCompilerTestDataSpecTest.kt b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/AbstractLLFirPreresolvedReversedDiagnosticCompilerTestDataSpecTest.kt new file mode 100644 index 00000000000..dc990058aad --- /dev/null +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/AbstractLLFirPreresolvedReversedDiagnosticCompilerTestDataSpecTest.kt @@ -0,0 +1,22 @@ +/* + * 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.analysis.low.level.api.fir.diagnostic.compiler.based + +import org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based.AbstractCompilerBasedTestForFir +import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostic.compiler.based.facades.LLFirAnalyzerFacadeFactoryWithPreresolveInReversedOrder +import org.jetbrains.kotlin.test.bind +import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder +import org.jetbrains.kotlin.test.runners.baseFirDiagnosticTestConfiguration + +abstract class AbstractLLFirPreresolvedReversedDiagnosticCompilerTestDataSpecTest : AbstractCompilerBasedTestForFir() { + override fun TestConfigurationBuilder.configureTest() { + baseFirDiagnosticTestConfiguration( + frontendFacade = ::LowLevelFirFrontendFacade.bind(LLFirAnalyzerFacadeFactoryWithPreresolveInReversedOrder) + ) + baseFirSpecDiagnosticTestConfigurationForIde() + useAfterAnalysisCheckers(::FirReversedSuppressor) + } +} diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/AbstractLLFirPreresolvedReversedDiagnosticCompilerTestDataTest.kt b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/AbstractLLFirPreresolvedReversedDiagnosticCompilerTestDataTest.kt new file mode 100644 index 00000000000..0b1260dc6db --- /dev/null +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/AbstractLLFirPreresolvedReversedDiagnosticCompilerTestDataTest.kt @@ -0,0 +1,54 @@ +/* + * 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.analysis.low.level.api.fir.diagnostic.compiler.based + +import org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based.AbstractCompilerBasedTestForFir +import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostic.compiler.based.facades.LLFirAnalyzerFacadeFactoryWithPreresolveInReversedOrder +import org.jetbrains.kotlin.test.bind +import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder +import org.jetbrains.kotlin.test.runners.baseFirDiagnosticTestConfiguration +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.WrappedException +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer +import org.jetbrains.kotlin.test.directives.model.SimpleDirectivesContainer +import org.jetbrains.kotlin.test.model.AfterAnalysisChecker +import org.jetbrains.kotlin.test.services.moduleStructure + +abstract class AbstractLLFirPreresolvedReversedDiagnosticCompilerTestDataTest : AbstractCompilerBasedTestForFir() { + override fun TestConfigurationBuilder.configureTest() { + baseFirDiagnosticTestConfiguration( + frontendFacade = ::LowLevelFirFrontendFacade.bind(LLFirAnalyzerFacadeFactoryWithPreresolveInReversedOrder) + ) + + useAfterAnalysisCheckers(::FirReversedSuppressor) + } +} + +internal class FirReversedSuppressor(testServices: TestServices) : AfterAnalysisChecker(testServices) { + override val directiveContainers: List get() = listOf(Companion) + + override fun suppressIfNeeded(failedAssertions: List): List { + if (!isDisabled()) { + return failedAssertions + } + + return if (failedAssertions.isEmpty()) { + listOf( + AssertionError( + "Test contains $IGNORE_REVERSED_RESOLVE directive but no errors was reported. Please remove directive", + ).wrap() + ) + } else { + emptyList() + } + } + + private fun isDisabled(): Boolean = IGNORE_REVERSED_RESOLVE in testServices.moduleStructure.allDirectives + + companion object : SimpleDirectivesContainer() { + val IGNORE_REVERSED_RESOLVE by directive("Temporary disables reversed resolve checks until the issue is fixed") + } +} diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosticCompilerTestFE10TestdataTestGenerated.java similarity index 99% rename from analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java rename to analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosticCompilerTestFE10TestdataTestGenerated.java index 9791d646bb8..79676debc98 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosticCompilerTestFE10TestdataTestGenerated.java @@ -17,7 +17,7 @@ import java.util.regex.Pattern; /** This class is generated by {@link org.jetbrains.kotlin.generators.tests.analysis.api.GenerateAnalysisApiTestsKt}. DO NOT MODIFY MANUALLY */ @SuppressWarnings("all") -public class DiagnosisCompilerTestFE10TestdataTestGenerated extends AbstractDiagnosisCompilerTestDataTest { +public class DiagnosticCompilerTestFE10TestdataTestGenerated extends AbstractDiagnosticCompilerTestDataTest { @Nested @TestMetadata("compiler/testData/diagnostics/tests") @TestDataPath("$PROJECT_ROOT") diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosisCompilerTestFirTestdataTestGenerated.java b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosticCompilerTestFirTestdataTestGenerated.java similarity index 99% rename from analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosisCompilerTestFirTestdataTestGenerated.java rename to analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosticCompilerTestFirTestdataTestGenerated.java index a9257facd5f..05fbbc8bc2f 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosisCompilerTestFirTestdataTestGenerated.java +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosticCompilerTestFirTestdataTestGenerated.java @@ -16,7 +16,7 @@ import java.util.regex.Pattern; /** This class is generated by {@link org.jetbrains.kotlin.generators.tests.analysis.api.GenerateAnalysisApiTestsKt}. DO NOT MODIFY MANUALLY */ @SuppressWarnings("all") -public class DiagnosisCompilerTestFirTestdataTestGenerated extends AbstractDiagnosisCompilerTestDataTest { +public class DiagnosticCompilerTestFirTestdataTestGenerated extends AbstractDiagnosticCompilerTestDataTest { @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve") @TestDataPath("$PROJECT_ROOT") diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/FirIdeSpecTestGenerated.java b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/FirIdeSpecTestGenerated.java index 6139186e021..bff5704f68d 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/FirIdeSpecTestGenerated.java +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/FirIdeSpecTestGenerated.java @@ -18,7 +18,7 @@ import java.util.regex.Pattern; @SuppressWarnings("all") @TestMetadata("compiler/tests-spec/testData/diagnostics") @TestDataPath("$PROJECT_ROOT") -public class FirIdeSpecTestGenerated extends AbstractLLFirDiagnosisCompilerTestDataSpecTest { +public class FirIdeSpecTestGenerated extends AbstractLLFirDiagnosticCompilerTestDataSpecTest { @Test public void testAllFilesPresentInDiagnostics() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "helpers", "linked/annotations", "linked/built-in-types-and-their-semantics", "linked/control--and-data-flow-analysis.control-flow-graph.expressions-1.conditional-expressions", "linked/control--and-data-flow-analysis/performing-analysis-on-the-control-flow-graph", "linked/declarations/classifier-declaration/class-declaration/nested-and-inner-classifiers", "linked/declarations/classifier-declaration/classifier-initialization", "linked/declarations/classifier-declaration/data-class-declaration", "linked/declarations/function-declaration", "linked/declarations/property-declaration/property-initialization", "linked/declarations/type-alias", "linked/expressions/call-and-property-access-expressions", "linked/expressions/function-literals", "linked/inheritance", "linked/overload-resolution/c-level-partition", "linked/overload-resolution/determining-function-applicability-for-a-specific-call/rationale", "linked/overloadable-operators", "linked/statements/assignments/simple-assignments", "linked/type-inference/local-type-inference", "linked/type-inference/smart-casts/smart-cast-types", "linked/type-system/subtyping/subtyping-for-nullable-types", "linked/type-system/type-kinds/type-parameters"); diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated.java b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated.java new file mode 100644 index 00000000000..c407502148d --- /dev/null +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated.java @@ -0,0 +1,40076 @@ +/* + * 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.analysis.low.level.api.fir.diagnostic.compiler.based; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +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.analysis.api.GenerateAnalysisApiTestsKt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +public class LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated extends AbstractLLFirPreresolvedReversedDiagnosticCompilerTestDataTest { + @Nested + @TestMetadata("compiler/testData/diagnostics/tests") + @TestDataPath("$PROJECT_ROOT") + public class Tests { + @Test + @TestMetadata("Abstract.kt") + public void testAbstract() throws Exception { + runTest("compiler/testData/diagnostics/tests/Abstract.kt"); + } + + @Test + @TestMetadata("AbstractAccessor.kt") + public void testAbstractAccessor() throws Exception { + runTest("compiler/testData/diagnostics/tests/AbstractAccessor.kt"); + } + + @Test + @TestMetadata("AbstractInAbstractClass.kt") + public void testAbstractInAbstractClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/AbstractInAbstractClass.kt"); + } + + @Test + @TestMetadata("AbstractInClass.kt") + public void testAbstractInClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/AbstractInClass.kt"); + } + + @Test + @TestMetadata("AbstractInTrait.kt") + public void testAbstractInTrait() throws Exception { + runTest("compiler/testData/diagnostics/tests/AbstractInTrait.kt"); + } + + @Test + public void testAllFilesPresentInTests() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("annotationArgumentWithAliasedArrayType.kt") + public void testAnnotationArgumentWithAliasedArrayType() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotationArgumentWithAliasedArrayType.kt"); + } + + @Test + @TestMetadata("AnonymousInitializerVarAndConstructor.kt") + public void testAnonymousInitializerVarAndConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/AnonymousInitializerVarAndConstructor.kt"); + } + + @Test + @TestMetadata("AnonymousInitializers.kt") + public void testAnonymousInitializers() throws Exception { + runTest("compiler/testData/diagnostics/tests/AnonymousInitializers.kt"); + } + + @Test + @TestMetadata("AssignToArrayElement.kt") + public void testAssignToArrayElement() throws Exception { + runTest("compiler/testData/diagnostics/tests/AssignToArrayElement.kt"); + } + + @Test + @TestMetadata("AutoCreatedIt.kt") + public void testAutoCreatedIt() throws Exception { + runTest("compiler/testData/diagnostics/tests/AutoCreatedIt.kt"); + } + + @Test + @TestMetadata("BacktickNames.kt") + public void testBacktickNames() throws Exception { + runTest("compiler/testData/diagnostics/tests/BacktickNames.kt"); + } + + @Test + @TestMetadata("Basic.kt") + public void testBasic() throws Exception { + runTest("compiler/testData/diagnostics/tests/Basic.kt"); + } + + @Test + @TestMetadata("BinaryCallsOnNullableValues.kt") + public void testBinaryCallsOnNullableValues() throws Exception { + runTest("compiler/testData/diagnostics/tests/BinaryCallsOnNullableValues.kt"); + } + + @Test + @TestMetadata("Bounds.kt") + public void testBounds() throws Exception { + runTest("compiler/testData/diagnostics/tests/Bounds.kt"); + } + + @Test + @TestMetadata("BreakContinue.kt") + public void testBreakContinue() throws Exception { + runTest("compiler/testData/diagnostics/tests/BreakContinue.kt"); + } + + @Test + @TestMetadata("BreakContinueInWhen_after.kt") + public void testBreakContinueInWhen_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/BreakContinueInWhen_after.kt"); + } + + @Test + @TestMetadata("BreakContinueInWhen_before.kt") + public void testBreakContinueInWhen_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/BreakContinueInWhen_before.kt"); + } + + @Test + @TestMetadata("Builders.kt") + public void testBuilders() throws Exception { + runTest("compiler/testData/diagnostics/tests/Builders.kt"); + } + + @Test + @TestMetadata("Casts.kt") + public void testCasts() throws Exception { + runTest("compiler/testData/diagnostics/tests/Casts.kt"); + } + + @Test + @TestMetadata("CharacterLiterals.kt") + public void testCharacterLiterals() throws Exception { + runTest("compiler/testData/diagnostics/tests/CharacterLiterals.kt"); + } + + @Test + @TestMetadata("checkTypeTest.kt") + public void testCheckTypeTest() throws Exception { + runTest("compiler/testData/diagnostics/tests/checkTypeTest.kt"); + } + + @Test + @TestMetadata("CompareToWithErrorType.kt") + public void testCompareToWithErrorType() throws Exception { + runTest("compiler/testData/diagnostics/tests/CompareToWithErrorType.kt"); + } + + @Test + @TestMetadata("Constants.kt") + public void testConstants() throws Exception { + runTest("compiler/testData/diagnostics/tests/Constants.kt"); + } + + @Test + @TestMetadata("Constructors.kt") + public void testConstructors() throws Exception { + runTest("compiler/testData/diagnostics/tests/Constructors.kt"); + } + + @Test + @TestMetadata("ConstructorsOfPrimitives.kt") + public void testConstructorsOfPrimitives() throws Exception { + runTest("compiler/testData/diagnostics/tests/ConstructorsOfPrimitives.kt"); + } + + @Test + @TestMetadata("CovariantOverrideType.kt") + public void testCovariantOverrideType() throws Exception { + runTest("compiler/testData/diagnostics/tests/CovariantOverrideType.kt"); + } + + @Test + @TestMetadata("DefaultValueForParameterInFunctionType.kt") + public void testDefaultValueForParameterInFunctionType() throws Exception { + runTest("compiler/testData/diagnostics/tests/DefaultValueForParameterInFunctionType.kt"); + } + + @Test + @TestMetadata("DefaultValuesCheckWithoutBody.kt") + public void testDefaultValuesCheckWithoutBody() throws Exception { + runTest("compiler/testData/diagnostics/tests/DefaultValuesCheckWithoutBody.kt"); + } + + @Test + @TestMetadata("DefaultValuesTypechecking.kt") + public void testDefaultValuesTypechecking() throws Exception { + runTest("compiler/testData/diagnostics/tests/DefaultValuesTypechecking.kt"); + } + + @Test + @TestMetadata("DeferredTypes.kt") + public void testDeferredTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/DeferredTypes.kt"); + } + + @Test + @TestMetadata("DeprecatedGetSetPropertyDelegateConvention.kt") + public void testDeprecatedGetSetPropertyDelegateConvention() throws Exception { + runTest("compiler/testData/diagnostics/tests/DeprecatedGetSetPropertyDelegateConvention.kt"); + } + + @Test + @TestMetadata("DeprecatedUnaryOperatorConventions.kt") + public void testDeprecatedUnaryOperatorConventions() throws Exception { + runTest("compiler/testData/diagnostics/tests/DeprecatedUnaryOperatorConventions.kt"); + } + + @Test + @TestMetadata("derivedIntersectionPropertyShadowsBaseClassField.kt") + public void testDerivedIntersectionPropertyShadowsBaseClassField() throws Exception { + runTest("compiler/testData/diagnostics/tests/derivedIntersectionPropertyShadowsBaseClassField.kt"); + } + + @Test + @TestMetadata("DiamondFunction.kt") + public void testDiamondFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/DiamondFunction.kt"); + } + + @Test + @TestMetadata("DiamondFunctionGeneric.kt") + public void testDiamondFunctionGeneric() throws Exception { + runTest("compiler/testData/diagnostics/tests/DiamondFunctionGeneric.kt"); + } + + @Test + @TestMetadata("DiamondProperty.kt") + public void testDiamondProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/DiamondProperty.kt"); + } + + @Test + @TestMetadata("Dollar.kt") + public void testDollar() throws Exception { + runTest("compiler/testData/diagnostics/tests/Dollar.kt"); + } + + @Test + @TestMetadata("EnumEntryAsType.kt") + public void testEnumEntryAsType() throws Exception { + runTest("compiler/testData/diagnostics/tests/EnumEntryAsType.kt"); + } + + @Test + @TestMetadata("ExtensionCallInvoke.kt") + public void testExtensionCallInvoke() throws Exception { + runTest("compiler/testData/diagnostics/tests/ExtensionCallInvoke.kt"); + } + + @Test + @TestMetadata("ExternalAccessors.kt") + public void testExternalAccessors() throws Exception { + runTest("compiler/testData/diagnostics/tests/ExternalAccessors.kt"); + } + + @Test + @TestMetadata("ExternalAndAbstract.kt") + public void testExternalAndAbstract() throws Exception { + runTest("compiler/testData/diagnostics/tests/ExternalAndAbstract.kt"); + } + + @Test + @TestMetadata("fileDependencyRecursion.kt") + public void testFileDependencyRecursion() throws Exception { + runTest("compiler/testData/diagnostics/tests/fileDependencyRecursion.kt"); + } + + @Test + @TestMetadata("ForRangeConventions.kt") + public void testForRangeConventions() throws Exception { + runTest("compiler/testData/diagnostics/tests/ForRangeConventions.kt"); + } + + @Test + @TestMetadata("FreeFunctionCalledAsExtension.kt") + public void testFreeFunctionCalledAsExtension() throws Exception { + runTest("compiler/testData/diagnostics/tests/FreeFunctionCalledAsExtension.kt"); + } + + @Test + @TestMetadata("FunctionCalleeExpressions.kt") + public void testFunctionCalleeExpressions() throws Exception { + runTest("compiler/testData/diagnostics/tests/FunctionCalleeExpressions.kt"); + } + + @Test + @TestMetadata("FunctionParameterWithoutType.kt") + public void testFunctionParameterWithoutType() throws Exception { + runTest("compiler/testData/diagnostics/tests/FunctionParameterWithoutType.kt"); + } + + @Test + @TestMetadata("FunctionReturnTypes.kt") + public void testFunctionReturnTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/FunctionReturnTypes.kt"); + } + + @Test + @TestMetadata("GenericArgumentConsistency.kt") + public void testGenericArgumentConsistency() throws Exception { + runTest("compiler/testData/diagnostics/tests/GenericArgumentConsistency.kt"); + } + + @Test + @TestMetadata("GenericFunctionIsLessSpecific.kt") + public void testGenericFunctionIsLessSpecific() throws Exception { + runTest("compiler/testData/diagnostics/tests/GenericFunctionIsLessSpecific.kt"); + } + + @Test + @TestMetadata("IdentityComparisonWithPrimitives.kt") + public void testIdentityComparisonWithPrimitives() throws Exception { + runTest("compiler/testData/diagnostics/tests/IdentityComparisonWithPrimitives.kt"); + } + + @Test + @TestMetadata("implicitIntersection.kt") + public void testImplicitIntersection() throws Exception { + runTest("compiler/testData/diagnostics/tests/implicitIntersection.kt"); + } + + @Test + @TestMetadata("implicitNestedIntersection.kt") + public void testImplicitNestedIntersection() throws Exception { + runTest("compiler/testData/diagnostics/tests/implicitNestedIntersection.kt"); + } + + @Test + @TestMetadata("implicitNothing.kt") + public void testImplicitNothing() throws Exception { + runTest("compiler/testData/diagnostics/tests/implicitNothing.kt"); + } + + @Test + @TestMetadata("IncDec.kt") + public void testIncDec() throws Exception { + runTest("compiler/testData/diagnostics/tests/IncDec.kt"); + } + + @Test + @TestMetadata("IncDecOperatorsInExpectClass.kt") + public void testIncDecOperatorsInExpectClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/IncDecOperatorsInExpectClass.kt"); + } + + @Test + @TestMetadata("IncorrectCharacterLiterals.kt") + public void testIncorrectCharacterLiterals() throws Exception { + runTest("compiler/testData/diagnostics/tests/IncorrectCharacterLiterals.kt"); + } + + @Test + @TestMetadata("incrementDecrementOnFullyQualified.kt") + public void testIncrementDecrementOnFullyQualified() throws Exception { + runTest("compiler/testData/diagnostics/tests/incrementDecrementOnFullyQualified.kt"); + } + + @Test + @TestMetadata("incrementDecrementOnObject.kt") + public void testIncrementDecrementOnObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/incrementDecrementOnObject.kt"); + } + + @Test + @TestMetadata("InferNullabilityInThenBlock.kt") + public void testInferNullabilityInThenBlock() throws Exception { + runTest("compiler/testData/diagnostics/tests/InferNullabilityInThenBlock.kt"); + } + + @Test + @TestMetadata("Infix.kt") + public void testInfix() throws Exception { + runTest("compiler/testData/diagnostics/tests/Infix.kt"); + } + + @Test + @TestMetadata("InfixModifierApplicability.kt") + public void testInfixModifierApplicability() throws Exception { + runTest("compiler/testData/diagnostics/tests/InfixModifierApplicability.kt"); + } + + @Test + @TestMetadata("initializedAfterRethrow.kt") + public void testInitializedAfterRethrow() throws Exception { + runTest("compiler/testData/diagnostics/tests/initializedAfterRethrow.kt"); + } + + @Test + @TestMetadata("inlineDeprecationsOnImplicitCalls.kt") + public void testInlineDeprecationsOnImplicitCalls() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineDeprecationsOnImplicitCalls.kt"); + } + + @Test + @TestMetadata("InvokeAndRecursiveResolve.kt") + public void testInvokeAndRecursiveResolve() throws Exception { + runTest("compiler/testData/diagnostics/tests/InvokeAndRecursiveResolve.kt"); + } + + @Test + @TestMetadata("IsExpressions.kt") + public void testIsExpressions() throws Exception { + runTest("compiler/testData/diagnostics/tests/IsExpressions.kt"); + } + + @Test + @TestMetadata("kt11167.kt") + public void testKt11167() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt11167.kt"); + } + + @Test + @TestMetadata("kt13401.kt") + public void testKt13401() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt13401.kt"); + } + + @Test + @TestMetadata("kt310.kt") + public void testKt310() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt310.kt"); + } + + @Test + @TestMetadata("kt34440.kt") + public void testKt34440() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt34440.kt"); + } + + @Test + @TestMetadata("kt34857.kt") + public void testKt34857() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt34857.kt"); + } + + @Test + @TestMetadata("kt435.kt") + public void testKt435() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt435.kt"); + } + + @Test + @TestMetadata("kt46483.kt") + public void testKt46483() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt46483.kt"); + } + + @Test + @TestMetadata("kt49438.kt") + public void testKt49438() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt49438.kt"); + } + + @Test + @TestMetadata("kt53.kt") + public void testKt53() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt53.kt"); + } + + @Test + @TestMetadata("kt53988.kt") + public void testKt53988() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt53988.kt"); + } + + @Test + @TestMetadata("kt54587_1.kt") + public void testKt54587_1() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt54587_1.kt"); + } + + @Test + @TestMetadata("kt54587_2.kt") + public void testKt54587_2() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt54587_2.kt"); + } + + @Test + @TestMetadata("kt55181.kt") + public void testKt55181() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt55181.kt"); + } + + @Test + @TestMetadata("kt55666.kt") + public void testKt55666() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt55666.kt"); + } + + @Test + @TestMetadata("kt55733.kt") + public void testKt55733() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt55733.kt"); + } + + @Test + @TestMetadata("kt56612.kt") + public void testKt56612() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt56612.kt"); + } + + @Test + @TestMetadata("kt56665.kt") + public void testKt56665() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt56665.kt"); + } + + @Test + @TestMetadata("kt56723.kt") + public void testKt56723() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt56723.kt"); + } + + @Test + @TestMetadata("kt56769.kt") + public void testKt56769() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt56769.kt"); + } + + @Test + @TestMetadata("kt56876.kt") + public void testKt56876() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt56876.kt"); + } + + @Test + @TestMetadata("kt56877.kt") + public void testKt56877() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt56877.kt"); + } + + @Test + @TestMetadata("kt57085.kt") + public void testKt57085() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt57085.kt"); + } + + @Test + @TestMetadata("kt57175.kt") + public void testKt57175() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt57175.kt"); + } + + @Test + @TestMetadata("kt57214.kt") + public void testKt57214() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt57214.kt"); + } + + @Test + @TestMetadata("LValueAssignment.kt") + public void testLValueAssignment() throws Exception { + runTest("compiler/testData/diagnostics/tests/LValueAssignment.kt"); + } + + @Test + @TestMetadata("LiteralAsResult.kt") + public void testLiteralAsResult() throws Exception { + runTest("compiler/testData/diagnostics/tests/LiteralAsResult.kt"); + } + + @Test + @TestMetadata("LocalClassAndShortSubpackageNames.kt") + public void testLocalClassAndShortSubpackageNames() throws Exception { + runTest("compiler/testData/diagnostics/tests/LocalClassAndShortSubpackageNames.kt"); + } + + @Test + @TestMetadata("localInterfaces.kt") + public void testLocalInterfaces() throws Exception { + runTest("compiler/testData/diagnostics/tests/localInterfaces.kt"); + } + + @Test + @TestMetadata("MultilineStringTemplates.kt") + public void testMultilineStringTemplates() throws Exception { + runTest("compiler/testData/diagnostics/tests/MultilineStringTemplates.kt"); + } + + @Test + @TestMetadata("MultipleBounds.kt") + public void testMultipleBounds() throws Exception { + runTest("compiler/testData/diagnostics/tests/MultipleBounds.kt"); + } + + @Test + @TestMetadata("NamedFunctionTypeParameterInSupertype.kt") + public void testNamedFunctionTypeParameterInSupertype() throws Exception { + runTest("compiler/testData/diagnostics/tests/NamedFunctionTypeParameterInSupertype.kt"); + } + + @Test + @TestMetadata("noLibraryProvidersDuplication.kt") + public void testNoLibraryProvidersDuplication() throws Exception { + runTest("compiler/testData/diagnostics/tests/noLibraryProvidersDuplication.kt"); + } + + @Test + @TestMetadata("noLibraryProvidersDuplicationWithMpp.kt") + public void testNoLibraryProvidersDuplicationWithMpp() throws Exception { + runTest("compiler/testData/diagnostics/tests/noLibraryProvidersDuplicationWithMpp.kt"); + } + + @Test + @TestMetadata("noSymbolProvidersDuplicationInDiamond.kt") + public void testNoSymbolProvidersDuplicationInDiamond() throws Exception { + runTest("compiler/testData/diagnostics/tests/noSymbolProvidersDuplicationInDiamond.kt"); + } + + @Test + @TestMetadata("Nullability.kt") + public void testNullability() throws Exception { + runTest("compiler/testData/diagnostics/tests/Nullability.kt"); + } + + @Test + @TestMetadata("NumberPrefixAndSuffix.kt") + public void testNumberPrefixAndSuffix() throws Exception { + runTest("compiler/testData/diagnostics/tests/NumberPrefixAndSuffix.kt"); + } + + @Test + @TestMetadata("ObjectWithConstructor.kt") + public void testObjectWithConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/ObjectWithConstructor.kt"); + } + + @Test + @TestMetadata("OperatorChecks.kt") + public void testOperatorChecks() throws Exception { + runTest("compiler/testData/diagnostics/tests/OperatorChecks.kt"); + } + + @Test + @TestMetadata("Operators.kt") + public void testOperators() throws Exception { + runTest("compiler/testData/diagnostics/tests/Operators.kt"); + } + + @Test + @TestMetadata("OperatorsWithWrongNames.kt") + public void testOperatorsWithWrongNames() throws Exception { + runTest("compiler/testData/diagnostics/tests/OperatorsWithWrongNames.kt"); + } + + @Test + @TestMetadata("OverrideFunctionWithParamDefaultValue.kt") + public void testOverrideFunctionWithParamDefaultValue() throws Exception { + runTest("compiler/testData/diagnostics/tests/OverrideFunctionWithParamDefaultValue.kt"); + } + + @Test + @TestMetadata("overrideNotNull_Fail.kt") + public void testOverrideNotNull_Fail() throws Exception { + runTest("compiler/testData/diagnostics/tests/overrideNotNull_Fail.kt"); + } + + @Test + @TestMetadata("overrideNotNull_Ok.kt") + public void testOverrideNotNull_Ok() throws Exception { + runTest("compiler/testData/diagnostics/tests/overrideNotNull_Ok.kt"); + } + + @Test + @TestMetadata("OverridenFunctionAndSpecifiedTypeParameter.kt") + public void testOverridenFunctionAndSpecifiedTypeParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/OverridenFunctionAndSpecifiedTypeParameter.kt"); + } + + @Test + @TestMetadata("OverridenSetterVisibility.kt") + public void testOverridenSetterVisibility() throws Exception { + runTest("compiler/testData/diagnostics/tests/OverridenSetterVisibility.kt"); + } + + @Test + @TestMetadata("OverridingVarByVal.kt") + public void testOverridingVarByVal() throws Exception { + runTest("compiler/testData/diagnostics/tests/OverridingVarByVal.kt"); + } + + @Test + @TestMetadata("PackageInExpressionPosition.kt") + public void testPackageInExpressionPosition() throws Exception { + runTest("compiler/testData/diagnostics/tests/PackageInExpressionPosition.kt"); + } + + @Test + @TestMetadata("PackageInTypePosition.kt") + public void testPackageInTypePosition() throws Exception { + runTest("compiler/testData/diagnostics/tests/PackageInTypePosition.kt"); + } + + @Test + @TestMetadata("PackageQualified.kt") + public void testPackageQualified() throws Exception { + runTest("compiler/testData/diagnostics/tests/PackageQualified.kt"); + } + + @Test + @TestMetadata("prefixIncReturnType.kt") + public void testPrefixIncReturnType() throws Exception { + runTest("compiler/testData/diagnostics/tests/prefixIncReturnType.kt"); + } + + @Test + @TestMetadata("prefixIncSmartCast.kt") + public void testPrefixIncSmartCast() throws Exception { + runTest("compiler/testData/diagnostics/tests/prefixIncSmartCast.kt"); + } + + @Test + @TestMetadata("PrimaryConstructors.kt") + public void testPrimaryConstructors() throws Exception { + runTest("compiler/testData/diagnostics/tests/PrimaryConstructors.kt"); + } + + @Test + @TestMetadata("PrivateFromOuterPackage.kt") + public void testPrivateFromOuterPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/PrivateFromOuterPackage.kt"); + } + + @Test + @TestMetadata("PrivateSetterForOverridden.kt") + public void testPrivateSetterForOverridden() throws Exception { + runTest("compiler/testData/diagnostics/tests/PrivateSetterForOverridden.kt"); + } + + @Test + @TestMetadata("ProcessingEmptyImport.kt") + public void testProcessingEmptyImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/ProcessingEmptyImport.kt"); + } + + @Test + @TestMetadata("ProjectionOnFunctionArgumentErrror.kt") + public void testProjectionOnFunctionArgumentErrror() throws Exception { + runTest("compiler/testData/diagnostics/tests/ProjectionOnFunctionArgumentErrror.kt"); + } + + @Test + @TestMetadata("ProjectionsInSupertypes.kt") + public void testProjectionsInSupertypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/ProjectionsInSupertypes.kt"); + } + + @Test + @TestMetadata("properDefaultInitializationInTailrec.kt") + public void testProperDefaultInitializationInTailrec() throws Exception { + runTest("compiler/testData/diagnostics/tests/properDefaultInitializationInTailrec.kt"); + } + + @Test + @TestMetadata("Properties.kt") + public void testProperties() throws Exception { + runTest("compiler/testData/diagnostics/tests/Properties.kt"); + } + + @Test + @TestMetadata("PropertyInitializers.kt") + public void testPropertyInitializers() throws Exception { + runTest("compiler/testData/diagnostics/tests/PropertyInitializers.kt"); + } + + @Test + @TestMetadata("protectedWithGenericsInDifferentPackage.kt") + public void testProtectedWithGenericsInDifferentPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/protectedWithGenericsInDifferentPackage.kt"); + } + + @Test + @TestMetadata("publishedApi.kt") + public void testPublishedApi() throws Exception { + runTest("compiler/testData/diagnostics/tests/publishedApi.kt"); + } + + @Test + @TestMetadata("QualifiedExpressions.kt") + public void testQualifiedExpressions() throws Exception { + runTest("compiler/testData/diagnostics/tests/QualifiedExpressions.kt"); + } + + @Test + @TestMetadata("rawCastToStarProjection_Fail.kt") + public void testRawCastToStarProjection_Fail() throws Exception { + runTest("compiler/testData/diagnostics/tests/rawCastToStarProjection_Fail.kt"); + } + + @Test + @TestMetadata("rawCastToStarProjection_Ok.kt") + public void testRawCastToStarProjection_Ok() throws Exception { + runTest("compiler/testData/diagnostics/tests/rawCastToStarProjection_Ok.kt"); + } + + @Test + @TestMetadata("RecursiveResolve.kt") + public void testRecursiveResolve() throws Exception { + runTest("compiler/testData/diagnostics/tests/RecursiveResolve.kt"); + } + + @Test + @TestMetadata("RecursiveTypeInference.kt") + public void testRecursiveTypeInference() throws Exception { + runTest("compiler/testData/diagnostics/tests/RecursiveTypeInference.kt"); + } + + @Test + @TestMetadata("RecursiveTypeParameterEqualityCheck.kt") + public void testRecursiveTypeParameterEqualityCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/RecursiveTypeParameterEqualityCheck.kt"); + } + + @Test + @TestMetadata("ReserveYield.kt") + public void testReserveYield() throws Exception { + runTest("compiler/testData/diagnostics/tests/ReserveYield.kt"); + } + + @Test + @TestMetadata("ReserveYield2.kt") + public void testReserveYield2() throws Exception { + runTest("compiler/testData/diagnostics/tests/ReserveYield2.kt"); + } + + @Test + @TestMetadata("ReserveYieldNoMore.kt") + public void testReserveYieldNoMore() throws Exception { + runTest("compiler/testData/diagnostics/tests/ReserveYieldNoMore.kt"); + } + + @Test + @TestMetadata("ReserveYieldNoMore2.kt") + public void testReserveYieldNoMore2() throws Exception { + runTest("compiler/testData/diagnostics/tests/ReserveYieldNoMore2.kt"); + } + + @Test + @TestMetadata("ResolveOfJavaGenerics.kt") + public void testResolveOfJavaGenerics() throws Exception { + runTest("compiler/testData/diagnostics/tests/ResolveOfJavaGenerics.kt"); + } + + @Test + @TestMetadata("ResolveToJava.kt") + public void testResolveToJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/ResolveToJava.kt"); + } + + @Test + @TestMetadata("Return.kt") + public void testReturn() throws Exception { + runTest("compiler/testData/diagnostics/tests/Return.kt"); + } + + @Test + @TestMetadata("ReturnInFunctionWithoutBody.kt") + public void testReturnInFunctionWithoutBody() throws Exception { + runTest("compiler/testData/diagnostics/tests/ReturnInFunctionWithoutBody.kt"); + } + + @Test + @TestMetadata("safeCall.kt") + public void testSafeCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/safeCall.kt"); + } + + @Test + @TestMetadata("SafeCallInvoke.kt") + public void testSafeCallInvoke() throws Exception { + runTest("compiler/testData/diagnostics/tests/SafeCallInvoke.kt"); + } + + @Test + @TestMetadata("SafeCallNonNullReceiver.kt") + public void testSafeCallNonNullReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/SafeCallNonNullReceiver.kt"); + } + + @Test + @TestMetadata("SafeCallNonNullReceiver2.kt") + public void testSafeCallNonNullReceiver2() throws Exception { + runTest("compiler/testData/diagnostics/tests/SafeCallNonNullReceiver2.kt"); + } + + @Test + @TestMetadata("SafeCallNonNullReceiverReturnNull.kt") + public void testSafeCallNonNullReceiverReturnNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/SafeCallNonNullReceiverReturnNull.kt"); + } + + @Test + @TestMetadata("SafeCallOnFakePackage.kt") + public void testSafeCallOnFakePackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/SafeCallOnFakePackage.kt"); + } + + @Test + @TestMetadata("SafeCallOnSuperReceiver.kt") + public void testSafeCallOnSuperReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/SafeCallOnSuperReceiver.kt"); + } + + @Test + @TestMetadata("SafeCallUnknownType.kt") + public void testSafeCallUnknownType() throws Exception { + runTest("compiler/testData/diagnostics/tests/SafeCallUnknownType.kt"); + } + + @Test + @TestMetadata("Serializable.kt") + public void testSerializable() throws Exception { + runTest("compiler/testData/diagnostics/tests/Serializable.kt"); + } + + @Test + @TestMetadata("SetterVisibility.kt") + public void testSetterVisibility() throws Exception { + runTest("compiler/testData/diagnostics/tests/SetterVisibility.kt"); + } + + @Test + @TestMetadata("ShiftFunctionTypes.kt") + public void testShiftFunctionTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/ShiftFunctionTypes.kt"); + } + + @Test + @TestMetadata("StarsInFunctionCalls.kt") + public void testStarsInFunctionCalls() throws Exception { + runTest("compiler/testData/diagnostics/tests/StarsInFunctionCalls.kt"); + } + + @Test + @TestMetadata("StringPrefixAndSuffix.kt") + public void testStringPrefixAndSuffix() throws Exception { + runTest("compiler/testData/diagnostics/tests/StringPrefixAndSuffix.kt"); + } + + @Test + @TestMetadata("StringTemplates.kt") + public void testStringTemplates() throws Exception { + runTest("compiler/testData/diagnostics/tests/StringTemplates.kt"); + } + + @Test + @TestMetadata("SupertypeListChecks.kt") + public void testSupertypeListChecks() throws Exception { + runTest("compiler/testData/diagnostics/tests/SupertypeListChecks.kt"); + } + + @Test + @TestMetadata("SyntaxErrorInTestHighlighting.kt") + public void testSyntaxErrorInTestHighlighting() throws Exception { + runTest("compiler/testData/diagnostics/tests/SyntaxErrorInTestHighlighting.kt"); + } + + @Test + @TestMetadata("SyntaxErrorInTestHighlightingEof.kt") + public void testSyntaxErrorInTestHighlightingEof() throws Exception { + runTest("compiler/testData/diagnostics/tests/SyntaxErrorInTestHighlightingEof.kt"); + } + + @Test + @TestMetadata("syntheticSet.kt") + public void testSyntheticSet() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticSet.kt"); + } + + @Test + @TestMetadata("syntheticSetFalsePositive.kt") + public void testSyntheticSetFalsePositive() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticSetFalsePositive.kt"); + } + + @Test + @TestMetadata("tailRecBasic.kt") + public void testTailRecBasic() throws Exception { + runTest("compiler/testData/diagnostics/tests/tailRecBasic.kt"); + } + + @Test + @TestMetadata("tailRecInNestedScopes.kt") + public void testTailRecInNestedScopes() throws Exception { + runTest("compiler/testData/diagnostics/tests/tailRecInNestedScopes.kt"); + } + + @Test + @TestMetadata("tailRecInTry.kt") + public void testTailRecInTry() throws Exception { + runTest("compiler/testData/diagnostics/tests/tailRecInTry.kt"); + } + + @Test + @TestMetadata("tailRecOnVirtualMember.kt") + public void testTailRecOnVirtualMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/tailRecOnVirtualMember.kt"); + } + + @Test + @TestMetadata("tailRecOnVirtualMemberError.kt") + public void testTailRecOnVirtualMemberError() throws Exception { + runTest("compiler/testData/diagnostics/tests/tailRecOnVirtualMemberError.kt"); + } + + @Test + @TestMetadata("tailRecOverridden.kt") + public void testTailRecOverridden() throws Exception { + runTest("compiler/testData/diagnostics/tests/tailRecOverridden.kt"); + } + + @Test + @TestMetadata("tailRecSingleton.kt") + public void testTailRecSingleton() throws Exception { + runTest("compiler/testData/diagnostics/tests/tailRecSingleton.kt"); + } + + @Test + @TestMetadata("tailRecWithDispatchReceiver.kt") + public void testTailRecWithDispatchReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/tailRecWithDispatchReceiver.kt"); + } + + @Test + @TestMetadata("tailRecWithExtensionReceiver.kt") + public void testTailRecWithExtensionReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/tailRecWithExtensionReceiver.kt"); + } + + @Test + @TestMetadata("tailRecursionComplex.kt") + public void testTailRecursionComplex() throws Exception { + runTest("compiler/testData/diagnostics/tests/tailRecursionComplex.kt"); + } + + @Test + @TestMetadata("TraitOverrideObjectMethods.kt") + public void testTraitOverrideObjectMethods() throws Exception { + runTest("compiler/testData/diagnostics/tests/TraitOverrideObjectMethods.kt"); + } + + @Test + @TestMetadata("TraitWithConstructor.kt") + public void testTraitWithConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/TraitWithConstructor.kt"); + } + + @Test + @TestMetadata("TypeInference.kt") + public void testTypeInference() throws Exception { + runTest("compiler/testData/diagnostics/tests/TypeInference.kt"); + } + + @Test + @TestMetadata("TypeMismatchOnOverrideWithSyntaxErrors.kt") + public void testTypeMismatchOnOverrideWithSyntaxErrors() throws Exception { + runTest("compiler/testData/diagnostics/tests/TypeMismatchOnOverrideWithSyntaxErrors.kt"); + } + + @Test + @TestMetadata("Underscore.kt") + public void testUnderscore() throws Exception { + runTest("compiler/testData/diagnostics/tests/Underscore.kt"); + } + + @Test + @TestMetadata("UnderscoreUsageInAnnotation.kt") + public void testUnderscoreUsageInAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/tests/UnderscoreUsageInAnnotation.kt"); + } + + @Test + @TestMetadata("UnderscoreUsageInCall.kt") + public void testUnderscoreUsageInCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/UnderscoreUsageInCall.kt"); + } + + @Test + @TestMetadata("UnderscoreUsageInCallableRefTypeLHS.kt") + public void testUnderscoreUsageInCallableRefTypeLHS() throws Exception { + runTest("compiler/testData/diagnostics/tests/UnderscoreUsageInCallableRefTypeLHS.kt"); + } + + @Test + @TestMetadata("UnderscoreUsageInType.kt") + public void testUnderscoreUsageInType() throws Exception { + runTest("compiler/testData/diagnostics/tests/UnderscoreUsageInType.kt"); + } + + @Test + @TestMetadata("UnderscoreUsageInVariableAsFunctionCall.kt") + public void testUnderscoreUsageInVariableAsFunctionCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/UnderscoreUsageInVariableAsFunctionCall.kt"); + } + + @Test + @TestMetadata("UnitByDefaultForFunctionTypes.kt") + public void testUnitByDefaultForFunctionTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/UnitByDefaultForFunctionTypes.kt"); + } + + @Test + @TestMetadata("UnitValue.kt") + public void testUnitValue() throws Exception { + runTest("compiler/testData/diagnostics/tests/UnitValue.kt"); + } + + @Test + @TestMetadata("unproperDefaultInitializationInTailrec.kt") + public void testUnproperDefaultInitializationInTailrec() throws Exception { + runTest("compiler/testData/diagnostics/tests/unproperDefaultInitializationInTailrec.kt"); + } + + @Test + @TestMetadata("Unresolved.kt") + public void testUnresolved() throws Exception { + runTest("compiler/testData/diagnostics/tests/Unresolved.kt"); + } + + @Test + @TestMetadata("UnusedInDestructuring.kt") + public void testUnusedInDestructuring() throws Exception { + runTest("compiler/testData/diagnostics/tests/UnusedInDestructuring.kt"); + } + + @Test + @TestMetadata("UnusedParameters.kt") + public void testUnusedParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/UnusedParameters.kt"); + } + + @Test + @TestMetadata("UnusedVariables.kt") + public void testUnusedVariables() throws Exception { + runTest("compiler/testData/diagnostics/tests/UnusedVariables.kt"); + } + + @Test + @TestMetadata("ValAndFunOverrideCompatibilityClash.kt") + public void testValAndFunOverrideCompatibilityClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/ValAndFunOverrideCompatibilityClash.kt"); + } + + @Test + @TestMetadata("VarargTypes.kt") + public void testVarargTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/VarargTypes.kt"); + } + + @Test + @TestMetadata("Varargs.kt") + public void testVarargs() throws Exception { + runTest("compiler/testData/diagnostics/tests/Varargs.kt"); + } + + @Test + @TestMetadata("Variance.kt") + public void testVariance() throws Exception { + runTest("compiler/testData/diagnostics/tests/Variance.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/annotations") + @TestDataPath("$PROJECT_ROOT") + public class Annotations { + @Test + public void testAllFilesPresentInAnnotations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("AmbigiousAnnotationConstructor.kt") + public void testAmbigiousAnnotationConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/AmbigiousAnnotationConstructor.kt"); + } + + @Test + @TestMetadata("AnnotatedBlock.kt") + public void testAnnotatedBlock() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/AnnotatedBlock.kt"); + } + + @Test + @TestMetadata("AnnotatedConstructor.kt") + public void testAnnotatedConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/AnnotatedConstructor.kt"); + } + + @Test + @TestMetadata("AnnotatedConstructorParams.kt") + public void testAnnotatedConstructorParams() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/AnnotatedConstructorParams.kt"); + } + + @Test + @TestMetadata("annotatedExpressionInsideAnnotation.kt") + public void testAnnotatedExpressionInsideAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/annotatedExpressionInsideAnnotation.kt"); + } + + @Test + @TestMetadata("AnnotatedLocalObjectFun.kt") + public void testAnnotatedLocalObjectFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/AnnotatedLocalObjectFun.kt"); + } + + @Test + @TestMetadata("AnnotatedLocalObjectProperty.kt") + public void testAnnotatedLocalObjectProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/AnnotatedLocalObjectProperty.kt"); + } + + @Test + @TestMetadata("AnnotatedLoop.kt") + public void testAnnotatedLoop() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/AnnotatedLoop.kt"); + } + + @Test + @TestMetadata("AnnotatedNullableTypes.kt") + public void testAnnotatedNullableTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/AnnotatedNullableTypes.kt"); + } + + @Test + @TestMetadata("AnnotatedResultType.kt") + public void testAnnotatedResultType() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/AnnotatedResultType.kt"); + } + + @Test + @TestMetadata("AnnotatedTryCatch.kt") + public void testAnnotatedTryCatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/AnnotatedTryCatch.kt"); + } + + @Test + @TestMetadata("AnnotationAsDefaultParameter.kt") + public void testAnnotationAsDefaultParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/AnnotationAsDefaultParameter.kt"); + } + + @Test + @TestMetadata("AnnotationForClassTypeParameter_15.kt") + public void testAnnotationForClassTypeParameter_15() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_15.kt"); + } + + @Test + @TestMetadata("AnnotationForClassTypeParameter_16.kt") + public void testAnnotationForClassTypeParameter_16() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_16.kt"); + } + + @Test + @TestMetadata("AnnotationForClassTypeParameter_typeUseFlag.kt") + public void testAnnotationForClassTypeParameter_typeUseFlag() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_typeUseFlag.kt"); + } + + @Test + @TestMetadata("AnnotationForFunctionTypeParameter.kt") + public void testAnnotationForFunctionTypeParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.kt"); + } + + @Test + @TestMetadata("AnnotationForObject.kt") + public void testAnnotationForObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/AnnotationForObject.kt"); + } + + @Test + @TestMetadata("AnnotationIdentifier.kt") + public void testAnnotationIdentifier() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/AnnotationIdentifier.kt"); + } + + @Test + @TestMetadata("annotationInheritance.kt") + public void testAnnotationInheritance() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/annotationInheritance.kt"); + } + + @Test + @TestMetadata("annotationModifier.kt") + public void testAnnotationModifier() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/annotationModifier.kt"); + } + + @Test + @TestMetadata("AnnotationOnObject.kt") + public void testAnnotationOnObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/AnnotationOnObject.kt"); + } + + @Test + @TestMetadata("annotationOnParameterInFunctionType.kt") + public void testAnnotationOnParameterInFunctionType() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/annotationOnParameterInFunctionType.kt"); + } + + @Test + @TestMetadata("annotationRenderingInTypes.kt") + public void testAnnotationRenderingInTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/annotationRenderingInTypes.kt"); + } + + @Test + @TestMetadata("AnnotationsForClasses.kt") + public void testAnnotationsForClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/AnnotationsForClasses.kt"); + } + + @Test + @TestMetadata("AnnotationsForPropertyTypeParameter.kt") + public void testAnnotationsForPropertyTypeParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.kt"); + } + + @Test + @TestMetadata("annotationsOnLambdaAsCallArgument.kt") + public void testAnnotationsOnLambdaAsCallArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/annotationsOnLambdaAsCallArgument.kt"); + } + + @Test + @TestMetadata("annotationsOnNullableTypes.kt") + public void testAnnotationsOnNullableTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/annotationsOnNullableTypes.kt"); + } + + @Test + @TestMetadata("arrayLiteralInAnnotationCompanion_after.kt") + public void testArrayLiteralInAnnotationCompanion_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/arrayLiteralInAnnotationCompanion_after.kt"); + } + + @Test + @TestMetadata("arrayLiteralInAnnotationCompanion_before.kt") + public void testArrayLiteralInAnnotationCompanion_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/arrayLiteralInAnnotationCompanion_before.kt"); + } + + @Test + @TestMetadata("atAnnotationResolve.kt") + public void testAtAnnotationResolve() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/atAnnotationResolve.kt"); + } + + @Test + @TestMetadata("BasicAnnotations.kt") + public void testBasicAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/BasicAnnotations.kt"); + } + + @Test + @TestMetadata("blockLevelOnTheSameLineWarning.kt") + public void testBlockLevelOnTheSameLineWarning() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/blockLevelOnTheSameLineWarning.kt"); + } + + @Test + @TestMetadata("ConstructorCall.kt") + public void testConstructorCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/ConstructorCall.kt"); + } + + @Test + @TestMetadata("ConstructorCallAllowed.kt") + public void testConstructorCallAllowed() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/ConstructorCallAllowed.kt"); + } + + @Test + @TestMetadata("cycleInParameters_after.kt") + public void testCycleInParameters_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/cycleInParameters_after.kt"); + } + + @Test + @TestMetadata("cycleInParameters_array.kt") + public void testCycleInParameters_array() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/cycleInParameters_array.kt"); + } + + @Test + @TestMetadata("cycleInParameters_before.kt") + public void testCycleInParameters_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/cycleInParameters_before.kt"); + } + + @Test + @TestMetadata("DanglingMixed.kt") + public void testDanglingMixed() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/DanglingMixed.kt"); + } + + @Test + @TestMetadata("DanglingNoBrackets.kt") + public void testDanglingNoBrackets() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/DanglingNoBrackets.kt"); + } + + @Test + @TestMetadata("DanglingWithBrackets.kt") + public void testDanglingWithBrackets() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/DanglingWithBrackets.kt"); + } + + @Test + @TestMetadata("Deprecated.kt") + public void testDeprecated() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/Deprecated.kt"); + } + + @Test + @TestMetadata("dontReportWarningAboutChangingExecutionOrderForVararg.kt") + public void testDontReportWarningAboutChangingExecutionOrderForVararg() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/dontReportWarningAboutChangingExecutionOrderForVararg.kt"); + } + + @Test + @TestMetadata("extensionFunctionType.kt") + public void testExtensionFunctionType() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/extensionFunctionType.kt"); + } + + @Test + @TestMetadata("forParameterAnnotationResolve.kt") + public void testForParameterAnnotationResolve() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/forParameterAnnotationResolve.kt"); + } + + @Test + @TestMetadata("illegalRequireKotlinValue.kt") + public void testIllegalRequireKotlinValue() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/illegalRequireKotlinValue.kt"); + } + + @Test + @TestMetadata("illegalSinceKotlinValue.kt") + public void testIllegalSinceKotlinValue() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/illegalSinceKotlinValue.kt"); + } + + @Test + @TestMetadata("inheritFromAnnotationClass.kt") + public void testInheritFromAnnotationClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/inheritFromAnnotationClass.kt"); + } + + @Test + @TestMetadata("inheritFromAnnotationClass2.kt") + public void testInheritFromAnnotationClass2() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/inheritFromAnnotationClass2.kt"); + } + + @Test + @TestMetadata("InheritingAnnotationClass.kt") + public void testInheritingAnnotationClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/InheritingAnnotationClass.kt"); + } + + @Test + @TestMetadata("invalidTypesInAnnotationConstructor.kt") + public void testInvalidTypesInAnnotationConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/invalidTypesInAnnotationConstructor.kt"); + } + + @Test + @TestMetadata("javaAnnotationAndJavaClassWithIt.kt") + public void testJavaAnnotationAndJavaClassWithIt() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/javaAnnotationAndJavaClassWithIt.kt"); + } + + @Test + @TestMetadata("JavaAnnotationConstructors.kt") + public void testJavaAnnotationConstructors() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/JavaAnnotationConstructors.kt"); + } + + @Test + @TestMetadata("javaAnnotationWithClassArray.kt") + public void testJavaAnnotationWithClassArray() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/javaAnnotationWithClassArray.kt"); + } + + @Test + @TestMetadata("JvmSerializableLambdaAnnotation.kt") + public void testJvmSerializableLambdaAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/JvmSerializableLambdaAnnotation.kt"); + } + + @Test + @TestMetadata("kt1860-negative.kt") + public void testKt1860_negative() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/kt1860-negative.kt"); + } + + @Test + @TestMetadata("kt1860-positive.kt") + public void testKt1860_positive() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/kt1860-positive.kt"); + } + + @Test + @TestMetadata("kt1886annotationBody_after.kt") + public void testKt1886annotationBody_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/kt1886annotationBody_after.kt"); + } + + @Test + @TestMetadata("kt1886annotationBody_before.kt") + public void testKt1886annotationBody_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/kt1886annotationBody_before.kt"); + } + + @Test + @TestMetadata("missingValOnParameter.kt") + public void testMissingValOnParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/missingValOnParameter.kt"); + } + + @Test + @TestMetadata("MultiDeclaration.kt") + public void testMultiDeclaration() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/MultiDeclaration.kt"); + } + + @Test + @TestMetadata("MutuallyRecursivelyAnnotatedGlobalFunction.kt") + public void testMutuallyRecursivelyAnnotatedGlobalFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/MutuallyRecursivelyAnnotatedGlobalFunction.kt"); + } + + @Test + @TestMetadata("nestedClassesInAnnotations.kt") + public void testNestedClassesInAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/nestedClassesInAnnotations.kt"); + } + + @Test + @TestMetadata("noNameProperty.kt") + public void testNoNameProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/noNameProperty.kt"); + } + + @Test + @TestMetadata("NonAnnotationClass.kt") + public void testNonAnnotationClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/NonAnnotationClass.kt"); + } + + @Test + @TestMetadata("onExpression.kt") + public void testOnExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/onExpression.kt"); + } + + @Test + @TestMetadata("onFunctionParameter.kt") + public void testOnFunctionParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/onFunctionParameter.kt"); + } + + @Test + @TestMetadata("onInitializer.kt") + public void testOnInitializer() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/onInitializer.kt"); + } + + @Test + @TestMetadata("onLoops.kt") + public void testOnLoops() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/onLoops.kt"); + } + + @Test + @TestMetadata("onLoopsUnreachable.kt") + public void testOnLoopsUnreachable() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/onLoopsUnreachable.kt"); + } + + @Test + @TestMetadata("onMultiDeclaration.kt") + public void testOnMultiDeclaration() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/onMultiDeclaration.kt"); + } + + @Test + @TestMetadata("RecursivelyAnnotated.kt") + public void testRecursivelyAnnotated() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotated.kt"); + } + + @Test + @TestMetadata("RecursivelyAnnotatedFunctionParameter.kt") + public void testRecursivelyAnnotatedFunctionParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedFunctionParameter.kt"); + } + + @Test + @TestMetadata("RecursivelyAnnotatedGlobalFunction.kt") + public void testRecursivelyAnnotatedGlobalFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedGlobalFunction.kt"); + } + + @Test + @TestMetadata("RecursivelyAnnotatedGlobalProperty.kt") + public void testRecursivelyAnnotatedGlobalProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedGlobalProperty.kt"); + } + + @Test + @TestMetadata("RecursivelyAnnotatedParameter.kt") + public void testRecursivelyAnnotatedParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameter.kt"); + } + + @Test + @TestMetadata("RecursivelyAnnotatedParameterType.kt") + public void testRecursivelyAnnotatedParameterType() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameterType.kt"); + } + + @Test + @TestMetadata("RecursivelyAnnotatedParameterWithAt.kt") + public void testRecursivelyAnnotatedParameterWithAt() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameterWithAt.kt"); + } + + @Test + @TestMetadata("RecursivelyAnnotatedProperty.kt") + public void testRecursivelyAnnotatedProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedProperty.kt"); + } + + @Test + @TestMetadata("RecursivelyIncorrectlyAnnotatedParameter.kt") + public void testRecursivelyIncorrectlyAnnotatedParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/RecursivelyIncorrectlyAnnotatedParameter.kt"); + } + + @Test + @TestMetadata("requireKotlin.kt") + public void testRequireKotlin() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/requireKotlin.kt"); + } + + @Test + @TestMetadata("RetentionsOfAnnotationWithExpressionTarget_after.kt") + public void testRetentionsOfAnnotationWithExpressionTarget_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/RetentionsOfAnnotationWithExpressionTarget_after.kt"); + } + + @Test + @TestMetadata("RetentionsOfAnnotationWithExpressionTarget_before.kt") + public void testRetentionsOfAnnotationWithExpressionTarget_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/RetentionsOfAnnotationWithExpressionTarget_before.kt"); + } + + @Test + @TestMetadata("typeAnnotations.kt") + public void testTypeAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/typeAnnotations.kt"); + } + + @Test + @TestMetadata("typeArgumentsInAnnotation.kt") + public void testTypeArgumentsInAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/typeArgumentsInAnnotation.kt"); + } + + @Test + @TestMetadata("typeParameterAsAnnotation.kt") + public void testTypeParameterAsAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/typeParameterAsAnnotation.kt"); + } + + @Test + @TestMetadata("UnresolvedAnnotationOnObject.kt") + public void testUnresolvedAnnotationOnObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/UnresolvedAnnotationOnObject.kt"); + } + + @Test + @TestMetadata("unresolvedReferenceRange.kt") + public void testUnresolvedReferenceRange() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/unresolvedReferenceRange.kt"); + } + + @Test + @TestMetadata("WrongAnnotationArgsOnObject.kt") + public void testWrongAnnotationArgsOnObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/WrongAnnotationArgsOnObject.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant") + @TestDataPath("$PROJECT_ROOT") + public class AnnotationParameterMustBeConstant { + @Test + public void testAllFilesPresentInAnnotationParameterMustBeConstant() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("annotationConstructorDefaultParameter.kt") + public void testAnnotationConstructorDefaultParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/annotationConstructorDefaultParameter.kt"); + } + + @Test + @TestMetadata("booleanLocalVal.kt") + public void testBooleanLocalVal() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/booleanLocalVal.kt"); + } + + @Test + @TestMetadata("compareAndEquals.kt") + public void testCompareAndEquals() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/compareAndEquals.kt"); + } + + @Test + @TestMetadata("enumConst_after.kt") + public void testEnumConst_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst_after.kt"); + } + + @Test + @TestMetadata("enumConst_before.kt") + public void testEnumConst_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst_before.kt"); + } + + @Test + @TestMetadata("javaProperties.kt") + public void testJavaProperties() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/javaProperties.kt"); + } + + @Test + @TestMetadata("kotlinProperties.kt") + public void testKotlinProperties() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/kotlinProperties.kt"); + } + + @Test + @TestMetadata("standaloneInExpression.kt") + public void testStandaloneInExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/standaloneInExpression.kt"); + } + + @Test + @TestMetadata("strings.kt") + public void testStrings() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/strings.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/annotations/functionalTypes") + @TestDataPath("$PROJECT_ROOT") + public class FunctionalTypes { + @Test + public void testAllFilesPresentInFunctionalTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/functionalTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("nonParenthesizedAnnotationsWithError.kt") + public void testNonParenthesizedAnnotationsWithError() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/functionalTypes/nonParenthesizedAnnotationsWithError.kt"); + } + + @Test + @TestMetadata("nonParenthesizedAnnotationsWithoutError.kt") + public void testNonParenthesizedAnnotationsWithoutError() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/functionalTypes/nonParenthesizedAnnotationsWithoutError.kt"); + } + + @Test + @TestMetadata("parenthesizedAnnotations.kt") + public void testParenthesizedAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/functionalTypes/parenthesizedAnnotations.kt"); + } + + @Test + @TestMetadata("propagteAnyAnnotations.kt") + public void testPropagteAnyAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/functionalTypes/propagteAnyAnnotations.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/annotations/options") + @TestDataPath("$PROJECT_ROOT") + public class Options { + @Test + public void testAllFilesPresentInOptions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/options"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("annotationAsArg.kt") + public void testAnnotationAsArg() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/annotationAsArg.kt"); + } + + @Test + @TestMetadata("annotationAsArgComplex.kt") + public void testAnnotationAsArgComplex() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/annotationAsArgComplex.kt"); + } + + @Test + @TestMetadata("assignment.kt") + public void testAssignment() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/assignment.kt"); + } + + @Test + @TestMetadata("documented.kt") + public void testDocumented() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/documented.kt"); + } + + @Test + @TestMetadata("forParam.kt") + public void testForParam() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/forParam.kt"); + } + + @Test + @TestMetadata("functionExpression.kt") + public void testFunctionExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/functionExpression.kt"); + } + + @Test + @TestMetadata("functions.kt") + public void testFunctions() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/functions.kt"); + } + + @Test + @TestMetadata("javaDocumented.kt") + public void testJavaDocumented() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/javaDocumented.kt"); + } + + @Test + @TestMetadata("javaKotlinTargetRetention.kt") + public void testJavaKotlinTargetRetention() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/javaKotlinTargetRetention.kt"); + } + + @Test + @TestMetadata("javaretention.kt") + public void testJavaretention() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/javaretention.kt"); + } + + @Test + @TestMetadata("multiDeclaration.kt") + public void testMultiDeclaration() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/multiDeclaration.kt"); + } + + @Test + @TestMetadata("objectLiteral.kt") + public void testObjectLiteral() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/objectLiteral.kt"); + } + + @Test + @TestMetadata("prefix.kt") + public void testPrefix() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/prefix.kt"); + } + + @Test + @TestMetadata("retention.kt") + public void testRetention() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/retention.kt"); + } + + @Test + @TestMetadata("setterParam.kt") + public void testSetterParam() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/setterParam.kt"); + } + + @Test + @TestMetadata("target.kt") + public void testTarget() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/target.kt"); + } + + @Test + @TestMetadata("unrepeatable.kt") + public void testUnrepeatable() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/unrepeatable.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/annotations/options/targets") + @TestDataPath("$PROJECT_ROOT") + public class Targets { + @Test + @TestMetadata("accessors.kt") + public void testAccessors() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/targets/accessors.kt"); + } + + @Test + public void testAllFilesPresentInTargets() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/options/targets"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("annotation.kt") + public void testAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/targets/annotation.kt"); + } + + @Test + @TestMetadata("classifier.kt") + public void testClassifier() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/targets/classifier.kt"); + } + + @Test + @TestMetadata("constructor.kt") + public void testConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/targets/constructor.kt"); + } + + @Test + @TestMetadata("empty.kt") + public void testEmpty() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/targets/empty.kt"); + } + + @Test + @TestMetadata("expr.kt") + public void testExpr() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/targets/expr.kt"); + } + + @Test + @TestMetadata("field.kt") + public void testField() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/targets/field.kt"); + } + + @Test + @TestMetadata("file.kt") + public void testFile() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/targets/file.kt"); + } + + @Test + @TestMetadata("function.kt") + public void testFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/targets/function.kt"); + } + + @Test + @TestMetadata("funtypeargs.kt") + public void testFuntypeargs() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/targets/funtypeargs.kt"); + } + + @Test + @TestMetadata("incorrect.kt") + public void testIncorrect() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/targets/incorrect.kt"); + } + + @Test + @TestMetadata("init.kt") + public void testInit() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/targets/init.kt"); + } + + @Test + @TestMetadata("java.kt") + public void testJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/targets/java.kt"); + } + + @Test + @TestMetadata("local.kt") + public void testLocal() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/targets/local.kt"); + } + + @Test + @TestMetadata("nested.kt") + public void testNested() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/targets/nested.kt"); + } + + @Test + @TestMetadata("property.kt") + public void testProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/targets/property.kt"); + } + + @Test + @TestMetadata("returntype.kt") + public void testReturntype() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/targets/returntype.kt"); + } + + @Test + @TestMetadata("suppress.kt") + public void testSuppress() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/targets/suppress.kt"); + } + + @Test + @TestMetadata("type.kt") + public void testType() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/targets/type.kt"); + } + + @Test + @TestMetadata("typeParams.kt") + public void testTypeParams() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/targets/typeParams.kt"); + } + + @Test + @TestMetadata("typeargs.kt") + public void testTypeargs() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/targets/typeargs.kt"); + } + + @Test + @TestMetadata("valueparam.kt") + public void testValueparam() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/options/targets/valueparam.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/annotations/parameters") + @TestDataPath("$PROJECT_ROOT") + public class Parameters { + @Test + public void testAllFilesPresentInParameters() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/parameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("byte.kt") + public void testByte() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/byte.kt"); + } + + @Test + @TestMetadata("char.kt") + public void testChar() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/char.kt"); + } + + @Test + @TestMetadata("double.kt") + public void testDouble() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/double.kt"); + } + + @Test + @TestMetadata("float.kt") + public void testFloat() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/float.kt"); + } + + @Test + @TestMetadata("int.kt") + public void testInt() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/int.kt"); + } + + @Test + @TestMetadata("long.kt") + public void testLong() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/long.kt"); + } + + @Test + @TestMetadata("short.kt") + public void testShort() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/short.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/annotations/parameters/expressions") + @TestDataPath("$PROJECT_ROOT") + public class Expressions { + @Test + public void testAllFilesPresentInExpressions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/parameters/expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("andAnd.kt") + public void testAndAnd() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/andAnd.kt"); + } + + @Test + @TestMetadata("boolean.kt") + public void testBoolean() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/boolean.kt"); + } + + @Test + @TestMetadata("char.kt") + public void testChar() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/char.kt"); + } + + @Test + @TestMetadata("compositeCallBinary.kt") + public void testCompositeCallBinary() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/compositeCallBinary.kt"); + } + + @Test + @TestMetadata("divide.kt") + public void testDivide() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/divide.kt"); + } + + @Test + @TestMetadata("double.kt") + public void testDouble() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/double.kt"); + } + + @Test + @TestMetadata("eqeq.kt") + public void testEqeq() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/eqeq.kt"); + } + + @Test + @TestMetadata("escapedString.kt") + public void testEscapedString() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/escapedString.kt"); + } + + @Test + @TestMetadata("float.kt") + public void testFloat() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/float.kt"); + } + + @Test + @TestMetadata("gt.kt") + public void testGt() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/gt.kt"); + } + + @Test + @TestMetadata("gteq.kt") + public void testGteq() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/gteq.kt"); + } + + @Test + @TestMetadata("intrincics.kt") + public void testIntrincics() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/intrincics.kt"); + } + + @Test + @TestMetadata("labeled.kt") + public void testLabeled() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/labeled.kt"); + } + + @Test + @TestMetadata("long.kt") + public void testLong() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/long.kt"); + } + + @Test + @TestMetadata("lt.kt") + public void testLt() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/lt.kt"); + } + + @Test + @TestMetadata("lteq.kt") + public void testLteq() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/lteq.kt"); + } + + @Test + @TestMetadata("maxValue.kt") + public void testMaxValue() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/maxValue.kt"); + } + + @Test + @TestMetadata("maxValueByte.kt") + public void testMaxValueByte() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/maxValueByte.kt"); + } + + @Test + @TestMetadata("maxValueInt.kt") + public void testMaxValueInt() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/maxValueInt.kt"); + } + + @Test + @TestMetadata("miltiply.kt") + public void testMiltiply() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/miltiply.kt"); + } + + @Test + @TestMetadata("minus.kt") + public void testMinus() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/minus.kt"); + } + + @Test + @TestMetadata("mod.kt") + public void testMod() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/mod.kt"); + } + + @Test + @TestMetadata("multilineString.kt") + public void testMultilineString() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/multilineString.kt"); + } + + @Test + @TestMetadata("not.kt") + public void testNot() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/not.kt"); + } + + @Test + @TestMetadata("noteq.kt") + public void testNoteq() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/noteq.kt"); + } + + @Test + @TestMetadata("orOr.kt") + public void testOrOr() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/orOr.kt"); + } + + @Test + @TestMetadata("paranthesized.kt") + public void testParanthesized() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/paranthesized.kt"); + } + + @Test + @TestMetadata("plus.kt") + public void testPlus() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/plus.kt"); + } + + @Test + @TestMetadata("simpleCallBinary.kt") + public void testSimpleCallBinary() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/simpleCallBinary.kt"); + } + + @Test + @TestMetadata("stringPlusInt.kt") + public void testStringPlusInt() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/stringPlusInt.kt"); + } + + @Test + @TestMetadata("stringTemplate.kt") + public void testStringTemplate() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/stringTemplate.kt"); + } + + @Test + @TestMetadata("strings.kt") + public void testStrings() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/strings.kt"); + } + + @Test + @TestMetadata("unaryMinus.kt") + public void testUnaryMinus() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/unaryMinus.kt"); + } + + @Test + @TestMetadata("unaryPlus.kt") + public void testUnaryPlus() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/parameters/expressions/unaryPlus.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/annotations/rendering") + @TestDataPath("$PROJECT_ROOT") + public class Rendering { + @Test + public void testAllFilesPresentInRendering() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/rendering"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("cannotOverrideInvisibleMember.kt") + public void testCannotOverrideInvisibleMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/rendering/cannotOverrideInvisibleMember.kt"); + } + + @Test + @TestMetadata("conflictingOverloads.kt") + public void testConflictingOverloads() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/rendering/conflictingOverloads.kt"); + } + + @Test + @TestMetadata("differentNamesForParameter.kt") + public void testDifferentNamesForParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/rendering/differentNamesForParameter.kt"); + } + + @Test + @TestMetadata("memberProjectedOut.kt") + public void testMemberProjectedOut() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/rendering/memberProjectedOut.kt"); + } + + @Test + @TestMetadata("multipleInheritedDefaults.kt") + public void testMultipleInheritedDefaults() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/rendering/multipleInheritedDefaults.kt"); + } + + @Test + @TestMetadata("notImplementedMembers.kt") + public void testNotImplementedMembers() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/rendering/notImplementedMembers.kt"); + } + + @Test + @TestMetadata("notImplementedMembersAroundJava.kt") + public void testNotImplementedMembersAroundJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/rendering/notImplementedMembersAroundJava.kt"); + } + + @Test + @TestMetadata("tooManyArguments.kt") + public void testTooManyArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/rendering/tooManyArguments.kt"); + } + + @Test + @TestMetadata("typeMismatchDueToTypeProjections.kt") + public void testTypeMismatchDueToTypeProjections() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/rendering/typeMismatchDueToTypeProjections.kt"); + } + + @Test + @TestMetadata("typeMismatchOnOverride.kt") + public void testTypeMismatchOnOverride() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/rendering/typeMismatchOnOverride.kt"); + } + + @Test + @TestMetadata("typeMismatchOnOverrideJavaNullable.kt") + public void testTypeMismatchOnOverrideJavaNullable() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/rendering/typeMismatchOnOverrideJavaNullable.kt"); + } + + @Test + @TestMetadata("unusedValue.kt") + public void testUnusedValue() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/rendering/unusedValue.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/annotations/repeatable") + @TestDataPath("$PROJECT_ROOT") + public class Repeatable { + @Test + public void testAllFilesPresentInRepeatable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/repeatable"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("containerAndAnnotationAreBothApplied_1_5.kt") + public void testContainerAndAnnotationAreBothApplied_1_5() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerAndAnnotationAreBothApplied_1_5.kt"); + } + + @Test + @TestMetadata("containerAndAnnotationAreBothApplied_1_6.kt") + public void testContainerAndAnnotationAreBothApplied_1_6() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerAndAnnotationAreBothApplied_1_6.kt"); + } + + @Test + @TestMetadata("containerArguments_1_5.kt") + public void testContainerArguments_1_5() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_5.kt"); + } + + @Test + @TestMetadata("containerArguments_1_6.kt") + public void testContainerArguments_1_6() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerArguments_1_6.kt"); + } + + @Test + @TestMetadata("containerRetention_1_5.kt") + public void testContainerRetention_1_5() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_5.kt"); + } + + @Test + @TestMetadata("containerRetention_1_6.kt") + public void testContainerRetention_1_6() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerRetention_1_6.kt"); + } + + @Test + @TestMetadata("containerTarget_1_6.kt") + public void testContainerTarget_1_6() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/containerTarget_1_6.kt"); + } + + @Test + @TestMetadata("javaRepeatableInKotlin.kt") + public void testJavaRepeatableInKotlin() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/javaRepeatableInKotlin.kt"); + } + + @Test + @TestMetadata("javaRepeatableJvmTarget6.kt") + public void testJavaRepeatableJvmTarget6() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/javaRepeatableJvmTarget6.kt"); + } + + @Test + @TestMetadata("javaRepeatable_1_5.kt") + public void testJavaRepeatable_1_5() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/javaRepeatable_1_5.kt"); + } + + @Test + @TestMetadata("javaRepeatable_1_6.kt") + public void testJavaRepeatable_1_6() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/javaRepeatable_1_6.kt"); + } + + @Test + @TestMetadata("javaUnrepeatable_1_5.kt") + public void testJavaUnrepeatable_1_5() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/javaUnrepeatable_1_5.kt"); + } + + @Test + @TestMetadata("javaUnrepeatable_1_6.kt") + public void testJavaUnrepeatable_1_6() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/javaUnrepeatable_1_6.kt"); + } + + @Test + @TestMetadata("kotlinRepeatable_1_5.kt") + public void testKotlinRepeatable_1_5() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/kotlinRepeatable_1_5.kt"); + } + + @Test + @TestMetadata("kotlinRepeatable_1_6.kt") + public void testKotlinRepeatable_1_6() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/kotlinRepeatable_1_6.kt"); + } + + @Test + @TestMetadata("nestedClassContainer_1_5.kt") + public void testNestedClassContainer_1_5() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/nestedClassContainer_1_5.kt"); + } + + @Test + @TestMetadata("nestedClassContainer_1_6.kt") + public void testNestedClassContainer_1_6() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/repeatable/nestedClassContainer_1_6.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/annotations/typeUse") + @TestDataPath("$PROJECT_ROOT") + public class TypeUse { + @Test + public void testAllFilesPresentInTypeUse() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/typeUse"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("kt19455.kt") + public void testKt19455() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/typeUse/kt19455.kt"); + } + + @Test + @TestMetadata("kt25876.kt") + public void testKt25876() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/typeUse/kt25876.kt"); + } + + @Test + @TestMetadata("kt45905.kt") + public void testKt45905() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/typeUse/kt45905.kt"); + } + + @Test + @TestMetadata("kt46173.kt") + public void testKt46173() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/typeUse/kt46173.kt"); + } + + @Test + @TestMetadata("kt47772.kt") + public void testKt47772() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/typeUse/kt47772.kt"); + } + + @Test + @TestMetadata("kt8325.kt") + public void testKt8325() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/typeUse/kt8325.kt"); + } + + @Test + @TestMetadata("nonTypeUseAnnotationOnType.kt") + public void testNonTypeUseAnnotationOnType() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/typeUse/nonTypeUseAnnotationOnType.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget") + @TestDataPath("$PROJECT_ROOT") + public class WithUseSiteTarget { + @Test + public void testAllFilesPresentInWithUseSiteTarget() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("DelegateAnnotations.kt") + public void testDelegateAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/DelegateAnnotations.kt"); + } + + @Test + @TestMetadata("diagnosticFileAnnotationInWrongPlace.kt") + public void testDiagnosticFileAnnotationInWrongPlace() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/diagnosticFileAnnotationInWrongPlace.kt"); + } + + @Test + @TestMetadata("diagnosticWithoutPackage.kt") + public void testDiagnosticWithoutPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/diagnosticWithoutPackage.kt"); + } + + @Test + @TestMetadata("diagnosticWithoutPackageWithSimpleAnnotation.kt") + public void testDiagnosticWithoutPackageWithSimpleAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/diagnosticWithoutPackageWithSimpleAnnotation.kt"); + } + + @Test + @TestMetadata("FieldAnnotations.kt") + public void testFieldAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/FieldAnnotations.kt"); + } + + @Test + @TestMetadata("fileAnnotationWithoutColon_after.kt") + public void testFileAnnotationWithoutColon_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/fileAnnotationWithoutColon_after.kt"); + } + + @Test + @TestMetadata("fileAnnotationWithoutColon_before.kt") + public void testFileAnnotationWithoutColon_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/fileAnnotationWithoutColon_before.kt"); + } + + @Test + @TestMetadata("FileAnnotations.kt") + public void testFileAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/FileAnnotations.kt"); + } + + @Test + @TestMetadata("GetterAnnotations.kt") + public void testGetterAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/GetterAnnotations.kt"); + } + + @Test + @TestMetadata("kt23992.kt") + public void testKt23992() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/kt23992.kt"); + } + + @Test + @TestMetadata("kt23992_after.kt") + public void testKt23992_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/kt23992_after.kt"); + } + + @Test + @TestMetadata("kt26638.kt") + public void testKt26638() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/kt26638.kt"); + } + + @Test + @TestMetadata("kt26638_after.kt") + public void testKt26638_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/kt26638_after.kt"); + } + + @Test + @TestMetadata("ParamAnnotations.kt") + public void testParamAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/ParamAnnotations.kt"); + } + + @Test + @TestMetadata("prohibitUseSiteGetTargetAnnotationsOff.kt") + public void testProhibitUseSiteGetTargetAnnotationsOff() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/prohibitUseSiteGetTargetAnnotationsOff.kt"); + } + + @Test + @TestMetadata("prohibitUseSiteGetTargetAnnotationsOn.kt") + public void testProhibitUseSiteGetTargetAnnotationsOn() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/prohibitUseSiteGetTargetAnnotationsOn.kt"); + } + + @Test + @TestMetadata("PropertyAnnotations.kt") + public void testPropertyAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/PropertyAnnotations.kt"); + } + + @Test + @TestMetadata("ReceiverAnnotations.kt") + public void testReceiverAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/ReceiverAnnotations.kt"); + } + + @Test + @TestMetadata("receiverUseSiteTargetOnExtensionFunction_after.kt") + public void testReceiverUseSiteTargetOnExtensionFunction_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/receiverUseSiteTargetOnExtensionFunction_after.kt"); + } + + @Test + @TestMetadata("receiverUseSiteTargetOnExtensionFunction_before.kt") + public void testReceiverUseSiteTargetOnExtensionFunction_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/receiverUseSiteTargetOnExtensionFunction_before.kt"); + } + + @Test + @TestMetadata("repeatable.kt") + public void testRepeatable() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/repeatable.kt"); + } + + @Test + @TestMetadata("SetterAnnotations.kt") + public void testSetterAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/SetterAnnotations.kt"); + } + + @Test + @TestMetadata("SparamAnnotations.kt") + public void testSparamAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/SparamAnnotations.kt"); + } + + @Test + @TestMetadata("wrongParamAnnotationsOnTypesError.kt") + public void testWrongParamAnnotationsOnTypesError() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/wrongParamAnnotationsOnTypesError.kt"); + } + + @Test + @TestMetadata("wrongParamAnnotationsOnTypes_after.kt") + public void testWrongParamAnnotationsOnTypes_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/wrongParamAnnotationsOnTypes_after.kt"); + } + + @Test + @TestMetadata("wrongParamAnnotationsOnTypes_before.kt") + public void testWrongParamAnnotationsOnTypes_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/wrongParamAnnotationsOnTypes_before.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/backingField") + @TestDataPath("$PROJECT_ROOT") + public class BackingField { + @Test + public void testAllFilesPresentInBackingField() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/backingField"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("CustomGetSet.kt") + public void testCustomGetSet() throws Exception { + runTest("compiler/testData/diagnostics/tests/backingField/CustomGetSet.kt"); + } + + @Test + @TestMetadata("CustomGetVal.kt") + public void testCustomGetVal() throws Exception { + runTest("compiler/testData/diagnostics/tests/backingField/CustomGetVal.kt"); + } + + @Test + @TestMetadata("CustomGetValGlobal.kt") + public void testCustomGetValGlobal() throws Exception { + runTest("compiler/testData/diagnostics/tests/backingField/CustomGetValGlobal.kt"); + } + + @Test + @TestMetadata("CustomGetVar.kt") + public void testCustomGetVar() throws Exception { + runTest("compiler/testData/diagnostics/tests/backingField/CustomGetVar.kt"); + } + + @Test + @TestMetadata("CustomSet.kt") + public void testCustomSet() throws Exception { + runTest("compiler/testData/diagnostics/tests/backingField/CustomSet.kt"); + } + + @Test + @TestMetadata("ExtensionProperty.kt") + public void testExtensionProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/backingField/ExtensionProperty.kt"); + } + + @Test + @TestMetadata("FieldAsParam.kt") + public void testFieldAsParam() throws Exception { + runTest("compiler/testData/diagnostics/tests/backingField/FieldAsParam.kt"); + } + + @Test + @TestMetadata("FieldAsProperty.kt") + public void testFieldAsProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/backingField/FieldAsProperty.kt"); + } + + @Test + @TestMetadata("FieldDerived.kt") + public void testFieldDerived() throws Exception { + runTest("compiler/testData/diagnostics/tests/backingField/FieldDerived.kt"); + } + + @Test + @TestMetadata("FieldInInterface.kt") + public void testFieldInInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/backingField/FieldInInterface.kt"); + } + + @Test + @TestMetadata("FieldInLocal.kt") + public void testFieldInLocal() throws Exception { + runTest("compiler/testData/diagnostics/tests/backingField/FieldInLocal.kt"); + } + + @Test + @TestMetadata("FieldOnVal.kt") + public void testFieldOnVal() throws Exception { + runTest("compiler/testData/diagnostics/tests/backingField/FieldOnVal.kt"); + } + + @Test + @TestMetadata("FieldOnVar.kt") + public void testFieldOnVar() throws Exception { + runTest("compiler/testData/diagnostics/tests/backingField/FieldOnVar.kt"); + } + + @Test + @TestMetadata("FieldReassignment_after.kt") + public void testFieldReassignment_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/backingField/FieldReassignment_after.kt"); + } + + @Test + @TestMetadata("FieldReassignment_before.kt") + public void testFieldReassignment_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/backingField/FieldReassignment_before.kt"); + } + + @Test + @TestMetadata("FieldShadow.kt") + public void testFieldShadow() throws Exception { + runTest("compiler/testData/diagnostics/tests/backingField/FieldShadow.kt"); + } + + @Test + @TestMetadata("InitCustomSetter.kt") + public void testInitCustomSetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/backingField/InitCustomSetter.kt"); + } + + @Test + @TestMetadata("InitOpenSetter.kt") + public void testInitOpenSetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/backingField/InitOpenSetter.kt"); + } + + @Test + @TestMetadata("kt782packageLevel.kt") + public void testKt782packageLevel() throws Exception { + runTest("compiler/testData/diagnostics/tests/backingField/kt782packageLevel.kt"); + } + + @Test + @TestMetadata("LocalDeclarations.kt") + public void testLocalDeclarations() throws Exception { + runTest("compiler/testData/diagnostics/tests/backingField/LocalDeclarations.kt"); + } + + @Test + @TestMetadata("SetterWithExplicitType.kt") + public void testSetterWithExplicitType() throws Exception { + runTest("compiler/testData/diagnostics/tests/backingField/SetterWithExplicitType.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/callableReference") + @TestDataPath("$PROJECT_ROOT") + public class CallableReference { + @Test + public void testAllFilesPresentInCallableReference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("bareType.kt") + public void testBareType() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/bareType.kt"); + } + + @Test + @TestMetadata("callableReferenceAsLastExpressionInBlock.kt") + public void testCallableReferenceAsLastExpressionInBlock() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/callableReferenceAsLastExpressionInBlock.kt"); + } + + @Test + @TestMetadata("callableReferenceAssignmentToVar.kt") + public void testCallableReferenceAssignmentToVar() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/callableReferenceAssignmentToVar.kt"); + } + + @Test + @TestMetadata("callableReferenceInWhenExpression.kt") + public void testCallableReferenceInWhenExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/callableReferenceInWhenExpression.kt"); + } + + @Test + @TestMetadata("callableReferenceWithMostSpecificGenericTypeParameter.kt") + public void testCallableReferenceWithMostSpecificGenericTypeParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/callableReferenceWithMostSpecificGenericTypeParameter.kt"); + } + + @Test + @TestMetadata("callableReferencesToCompanionMembers.kt") + public void testCallableReferencesToCompanionMembers() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/callableReferencesToCompanionMembers.kt"); + } + + @Test + @TestMetadata("classVsPackage.kt") + public void testClassVsPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/classVsPackage.kt"); + } + + @Test + @TestMetadata("compatibilityResolveWithVarargAndOperatorCall.kt") + public void testCompatibilityResolveWithVarargAndOperatorCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/compatibilityResolveWithVarargAndOperatorCall.kt"); + } + + @Test + @TestMetadata("constraintFromLHSWithCorrectDirection.kt") + public void testConstraintFromLHSWithCorrectDirection() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirection.kt"); + } + + @Test + @TestMetadata("constraintFromLHSWithCorrectDirectionError.kt") + public void testConstraintFromLHSWithCorrectDirectionError() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirectionError.kt"); + } + + @Test + @TestMetadata("correctCandidateWithCompatibilityForSeveralCandidates.kt") + public void testCorrectCandidateWithCompatibilityForSeveralCandidates() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/correctCandidateWithCompatibilityForSeveralCandidates.kt"); + } + + @Test + @TestMetadata("correctInfoAfterArrayLikeCall.kt") + public void testCorrectInfoAfterArrayLikeCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/correctInfoAfterArrayLikeCall.kt"); + } + + @Test + @TestMetadata("deprecateTopLevelReferenceWithCompanionLHS.kt") + public void testDeprecateTopLevelReferenceWithCompanionLHS() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/deprecateTopLevelReferenceWithCompanionLHS.kt"); + } + + @Test + @TestMetadata("deprecatedCompanionReceiverInParentheses.kt") + public void testDeprecatedCompanionReceiverInParentheses() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/deprecatedCompanionReceiverInParentheses.kt"); + } + + @Test + @TestMetadata("ea81649_errorPropertyLHS.kt") + public void testEa81649_errorPropertyLHS() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/ea81649_errorPropertyLHS.kt"); + } + + @Test + @TestMetadata("emptyLhs.kt") + public void testEmptyLhs() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/emptyLhs.kt"); + } + + @Test + @TestMetadata("expectedTypeAsSubtypeOfFunctionType.kt") + public void testExpectedTypeAsSubtypeOfFunctionType() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/expectedTypeAsSubtypeOfFunctionType.kt"); + } + + @Test + @TestMetadata("functionReferenceWithDefaultValueAsOtherFunctionType.kt") + public void testFunctionReferenceWithDefaultValueAsOtherFunctionType() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/functionReferenceWithDefaultValueAsOtherFunctionType.kt"); + } + + @Test + @TestMetadata("functionReferenceWithDefaultValueAsOtherFunctionType_enabled.kt") + public void testFunctionReferenceWithDefaultValueAsOtherFunctionType_enabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/functionReferenceWithDefaultValueAsOtherFunctionType_enabled.kt"); + } + + @Test + @TestMetadata("genericCallWithReferenceAgainstVararg.kt") + public void testGenericCallWithReferenceAgainstVararg() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/genericCallWithReferenceAgainstVararg.kt"); + } + + @Test + @TestMetadata("genericCallWithReferenceAgainstVarargAndKFunction.kt") + public void testGenericCallWithReferenceAgainstVarargAndKFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/genericCallWithReferenceAgainstVarargAndKFunction.kt"); + } + + @Test + @TestMetadata("kt15439_completeCall.kt") + public void testKt15439_completeCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/kt15439_completeCall.kt"); + } + + @Test + @TestMetadata("kt25433.kt") + public void testKt25433() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/kt25433.kt"); + } + + @Test + @TestMetadata("kt31981.kt") + public void testKt31981() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/kt31981.kt"); + } + + @Test + @TestMetadata("kt32256.kt") + public void testKt32256() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/kt32256.kt"); + } + + @Test + @TestMetadata("kt32267.kt") + public void testKt32267() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/kt32267.kt"); + } + + @Test + @TestMetadata("kt34314.kt") + public void testKt34314() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/kt34314.kt"); + } + + @Test + @TestMetadata("kt34314_lambda.kt") + public void testKt34314_lambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/kt34314_lambda.kt"); + } + + @Test + @TestMetadata("kt35105.kt") + public void testKt35105() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/kt35105.kt"); + } + + @Test + @TestMetadata("kt35959.kt") + public void testKt35959() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/kt35959.kt"); + } + + @Test + @TestMetadata("kt37530.kt") + public void testKt37530() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/kt37530.kt"); + } + + @Test + @TestMetadata("kt46437.kt") + public void testKt46437() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/kt46437.kt"); + } + + @Test + @TestMetadata("kt49038.kt") + public void testKt49038() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/kt49038.kt"); + } + + @Test + @TestMetadata("kt52503.kt") + public void testKt52503() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/kt52503.kt"); + } + + @Test + @TestMetadata("kt7430_wrongClassOnLHS.kt") + public void testKt7430_wrongClassOnLHS() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/kt7430_wrongClassOnLHS.kt"); + } + + @Test + @TestMetadata("lambdaResult.kt") + public void testLambdaResult() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/lambdaResult.kt"); + } + + @Test + @TestMetadata("memberExtensionsImportedFromObjectsUnsupported.kt") + public void testMemberExtensionsImportedFromObjectsUnsupported() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/memberExtensionsImportedFromObjectsUnsupported.kt"); + } + + @Test + @TestMetadata("noAmbiguityWhenAllReferencesAreInapplicable.kt") + public void testNoAmbiguityWhenAllReferencesAreInapplicable() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/noAmbiguityWhenAllReferencesAreInapplicable.kt"); + } + + @Test + @TestMetadata("noCompatibilityResolveWithProressiveModeForNI.kt") + public void testNoCompatibilityResolveWithProressiveModeForNI() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/noCompatibilityResolveWithProressiveModeForNI.kt"); + } + + @Test + @TestMetadata("noExceptionOnRedCodeWithArrayLikeCall.kt") + public void testNoExceptionOnRedCodeWithArrayLikeCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/noExceptionOnRedCodeWithArrayLikeCall.kt"); + } + + @Test + @TestMetadata("overloadResolutionWithDefaults.kt") + public void testOverloadResolutionWithDefaults() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/overloadResolutionWithDefaults.kt"); + } + + @Test + @TestMetadata("packageInLhs.kt") + public void testPackageInLhs() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/packageInLhs.kt"); + } + + @Test + @TestMetadata("parsingPriorityOfGenericArgumentsVsLess.kt") + public void testParsingPriorityOfGenericArgumentsVsLess() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/parsingPriorityOfGenericArgumentsVsLess.kt"); + } + + @Test + @TestMetadata("propertyOfNestedGenericClass.kt") + public void testPropertyOfNestedGenericClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/propertyOfNestedGenericClass.kt"); + } + + @Test + @TestMetadata("referenceAdaptationCompatibility.kt") + public void testReferenceAdaptationCompatibility() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/referenceAdaptationCompatibility.kt"); + } + + @Test + @TestMetadata("referenceInCycleInProperties.kt") + public void testReferenceInCycleInProperties() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/referenceInCycleInProperties.kt"); + } + + @Test + @TestMetadata("referenceToCompanionObjectMemberViaClassName.kt") + public void testReferenceToCompanionObjectMemberViaClassName() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/referenceToCompanionObjectMemberViaClassName.kt"); + } + + @Test + @TestMetadata("referenceToCompanionObjectMemberViaClassNameCompatibility.kt") + public void testReferenceToCompanionObjectMemberViaClassNameCompatibility() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/referenceToCompanionObjectMemberViaClassNameCompatibility.kt"); + } + + @Test + @TestMetadata("rewriteAtSliceOnGetOperator.kt") + public void testRewriteAtSliceOnGetOperator() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/rewriteAtSliceOnGetOperator.kt"); + } + + @Test + @TestMetadata("sam.kt") + public void testSam() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/sam.kt"); + } + + @Test + @TestMetadata("subtypeArgumentFromRHSForReference.kt") + public void testSubtypeArgumentFromRHSForReference() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/subtypeArgumentFromRHSForReference.kt"); + } + + @Test + @TestMetadata("suspendCallableReference.kt") + public void testSuspendCallableReference() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/suspendCallableReference.kt"); + } + + @Test + @TestMetadata("typealiases.kt") + public void testTypealiases() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/typealiases.kt"); + } + + @Test + @TestMetadata("unitAdaptationForReferenceCompatibility.kt") + public void testUnitAdaptationForReferenceCompatibility() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/unitAdaptationForReferenceCompatibility.kt"); + } + + @Test + @TestMetadata("unused.kt") + public void testUnused() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/unused.kt"); + } + + @Test + @TestMetadata("whitespacesInExpression.kt") + public void testWhitespacesInExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/whitespacesInExpression.kt"); + } + + @Test + @TestMetadata("withQuestionMarks.kt") + public void testWithQuestionMarks() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/withQuestionMarks.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/callableReference/adapted") + @TestDataPath("$PROJECT_ROOT") + public class Adapted { + @Test + @TestMetadata("adaptationByExpectTypeOutsideCall.kt") + public void testAdaptationByExpectTypeOutsideCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/adapted/adaptationByExpectTypeOutsideCall.kt"); + } + + @Test + @TestMetadata("adaptationInWhenWithMapOf.kt") + public void testAdaptationInWhenWithMapOf() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/adapted/adaptationInWhenWithMapOf.kt"); + } + + @Test + @TestMetadata("adaptationToOverridenWithoutDefault.kt") + public void testAdaptationToOverridenWithoutDefault() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/adapted/adaptationToOverridenWithoutDefault.kt"); + } + + @Test + public void testAllFilesPresentInAdapted() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/adapted"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("noKFunctionForAdaptation.kt") + public void testNoKFunctionForAdaptation() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/adapted/noKFunctionForAdaptation.kt"); + } + + @Test + @TestMetadata("simpleAdaptationOutsideOfCall.kt") + public void testSimpleAdaptationOutsideOfCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/adapted/simpleAdaptationOutsideOfCall.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/callableReference/bound") + @TestDataPath("$PROJECT_ROOT") + public class Bound { + @Test + public void testAllFilesPresentInBound() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("classVsStarImportedCompanion.kt") + public void testClassVsStarImportedCompanion() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/bound/classVsStarImportedCompanion.kt"); + } + + @Test + @TestMetadata("classVsStarImportedObject.kt") + public void testClassVsStarImportedObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/bound/classVsStarImportedObject.kt"); + } + + @Test + @TestMetadata("companionObject.kt") + public void testCompanionObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/bound/companionObject.kt"); + } + + @Test + @TestMetadata("controlFlow.kt") + public void testControlFlow() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/bound/controlFlow.kt"); + } + + @Test + @TestMetadata("dataFlow.kt") + public void testDataFlow() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/bound/dataFlow.kt"); + } + + @Test + @TestMetadata("expectedType.kt") + public void testExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/bound/expectedType.kt"); + } + + @Test + @TestMetadata("expressionWithNullableType.kt") + public void testExpressionWithNullableType() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/bound/expressionWithNullableType.kt"); + } + + @Test + @TestMetadata("functionCallWithoutArguments.kt") + public void testFunctionCallWithoutArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/bound/functionCallWithoutArguments.kt"); + } + + @Test + @TestMetadata("innerNested.kt") + public void testInnerNested() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/bound/innerNested.kt"); + } + + @Test + @TestMetadata("kt12843.kt") + public void testKt12843() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/bound/kt12843.kt"); + } + + @Test + @TestMetadata("noThisInSuperCall.kt") + public void testNoThisInSuperCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/bound/noThisInSuperCall.kt"); + } + + @Test + @TestMetadata("object.kt") + public void testObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/bound/object.kt"); + } + + @Test + @TestMetadata("privateToThis.kt") + public void testPrivateToThis() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/bound/privateToThis.kt"); + } + + @Test + @TestMetadata("referenceToStaticMethodOnInstance.kt") + public void testReferenceToStaticMethodOnInstance() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/bound/referenceToStaticMethodOnInstance.kt"); + } + + @Test + @TestMetadata("reservedExpressionSyntax.kt") + public void testReservedExpressionSyntax() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax.kt"); + } + + @Test + @TestMetadata("reservedExpressionSyntax2.kt") + public void testReservedExpressionSyntax2() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax2.kt"); + } + + @Test + @TestMetadata("reservedExpressionSyntax3.kt") + public void testReservedExpressionSyntax3() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax3.kt"); + } + + @Test + @TestMetadata("syntheticExtensionOnLHS.kt") + public void testSyntheticExtensionOnLHS() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/bound/syntheticExtensionOnLHS.kt"); + } + + @Test + @TestMetadata("valueOfTypeParameterType.kt") + public void testValueOfTypeParameterType() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/bound/valueOfTypeParameterType.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/callableReference/function") + @TestDataPath("$PROJECT_ROOT") + public class Function { + @Test + @TestMetadata("abstractClassConstructors.kt") + public void testAbstractClassConstructors() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/abstractClassConstructors.kt"); + } + + @Test + public void testAllFilesPresentInFunction() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("ambiguityTopLevelVsTopLevel.kt") + public void testAmbiguityTopLevelVsTopLevel() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/ambiguityTopLevelVsTopLevel.kt"); + } + + @Test + @TestMetadata("annotationClassConstructor.kt") + public void testAnnotationClassConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/annotationClassConstructor.kt"); + } + + @Test + @TestMetadata("callableRefrenceOnNestedObject.kt") + public void testCallableRefrenceOnNestedObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/callableRefrenceOnNestedObject.kt"); + } + + @Test + @TestMetadata("classMemberVsConstructorLikeFunction.kt") + public void testClassMemberVsConstructorLikeFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/classMemberVsConstructorLikeFunction.kt"); + } + + @Test + @TestMetadata("constructorFromClass.kt") + public void testConstructorFromClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/constructorFromClass.kt"); + } + + @Test + @TestMetadata("constructorFromCompanion.kt") + public void testConstructorFromCompanion() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/constructorFromCompanion.kt"); + } + + @Test + @TestMetadata("constructorFromExtension.kt") + public void testConstructorFromExtension() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/constructorFromExtension.kt"); + } + + @Test + @TestMetadata("constructorFromExtensionInClass.kt") + public void testConstructorFromExtensionInClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/constructorFromExtensionInClass.kt"); + } + + @Test + @TestMetadata("constructorFromTopLevel.kt") + public void testConstructorFromTopLevel() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/constructorFromTopLevel.kt"); + } + + @Test + @TestMetadata("constructorOfNestedClassInObject.kt") + public void testConstructorOfNestedClassInObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/constructorOfNestedClassInObject.kt"); + } + + @Test + @TestMetadata("differentPackageClass.kt") + public void testDifferentPackageClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/differentPackageClass.kt"); + } + + @Test + @TestMetadata("differentPackageExtension.kt") + public void testDifferentPackageExtension() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/differentPackageExtension.kt"); + } + + @Test + @TestMetadata("differentPackageTopLevel.kt") + public void testDifferentPackageTopLevel() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/differentPackageTopLevel.kt"); + } + + @Test + @TestMetadata("empty.kt") + public void testEmpty() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/empty.kt"); + } + + @Test + @TestMetadata("extensionFromTopLevel.kt") + public void testExtensionFromTopLevel() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/extensionFromTopLevel.kt"); + } + + @Test + @TestMetadata("extensionInClassDisallowed.kt") + public void testExtensionInClassDisallowed() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/extensionInClassDisallowed.kt"); + } + + @Test + @TestMetadata("extensionOnNullable.kt") + public void testExtensionOnNullable() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/extensionOnNullable.kt"); + } + + @Test + @TestMetadata("extensionToSupertype.kt") + public void testExtensionToSupertype() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/extensionToSupertype.kt"); + } + + @Test + @TestMetadata("fakeOverrideType.kt") + public void testFakeOverrideType() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/fakeOverrideType.kt"); + } + + @Test + @TestMetadata("genericClassFromTopLevel.kt") + public void testGenericClassFromTopLevel() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/genericClassFromTopLevel.kt"); + } + + @Test + @TestMetadata("importedInnerConstructor.kt") + public void testImportedInnerConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/importedInnerConstructor.kt"); + } + + @Test + @TestMetadata("innerConstructorFromClass.kt") + public void testInnerConstructorFromClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromClass.kt"); + } + + @Test + @TestMetadata("innerConstructorFromExtension.kt") + public void testInnerConstructorFromExtension() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromExtension.kt"); + } + + @Test + @TestMetadata("innerConstructorFromTopLevel.kt") + public void testInnerConstructorFromTopLevel() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromTopLevel.kt"); + } + + @Test + @TestMetadata("javaStaticMethod.kt") + public void testJavaStaticMethod() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/javaStaticMethod.kt"); + } + + @Test + @TestMetadata("lhsNotAClass.kt") + public void testLhsNotAClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/lhsNotAClass.kt"); + } + + @Test + @TestMetadata("localConstructor.kt") + public void testLocalConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/localConstructor.kt"); + } + + @Test + @TestMetadata("localConstructorFromExtensionInLocalClass.kt") + public void testLocalConstructorFromExtensionInLocalClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/localConstructorFromExtensionInLocalClass.kt"); + } + + @Test + @TestMetadata("localConstructorFromLocalClass.kt") + public void testLocalConstructorFromLocalClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/localConstructorFromLocalClass.kt"); + } + + @Test + @TestMetadata("localConstructorFromLocalExtension.kt") + public void testLocalConstructorFromLocalExtension() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/localConstructorFromLocalExtension.kt"); + } + + @Test + @TestMetadata("localNamedFun.kt") + public void testLocalNamedFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/localNamedFun.kt"); + } + + @Test + @TestMetadata("localNamedFunFromExtensionInLocalClass.kt") + public void testLocalNamedFunFromExtensionInLocalClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/localNamedFunFromExtensionInLocalClass.kt"); + } + + @Test + @TestMetadata("localNamedFunFromLocalClass.kt") + public void testLocalNamedFunFromLocalClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/localNamedFunFromLocalClass.kt"); + } + + @Test + @TestMetadata("localNamedFunFromLocalExtension.kt") + public void testLocalNamedFunFromLocalExtension() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/localNamedFunFromLocalExtension.kt"); + } + + @Test + @TestMetadata("longQualifiedName.kt") + public void testLongQualifiedName() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/longQualifiedName.kt"); + } + + @Test + @TestMetadata("longQualifiedNameGeneric.kt") + public void testLongQualifiedNameGeneric() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/longQualifiedNameGeneric.kt"); + } + + @Test + @TestMetadata("memberFromTopLevel.kt") + public void testMemberFromTopLevel() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/memberFromTopLevel.kt"); + } + + @Test + @TestMetadata("nestedConstructorFromClass.kt") + public void testNestedConstructorFromClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/nestedConstructorFromClass.kt"); + } + + @Test + @TestMetadata("nestedConstructorFromExtension.kt") + public void testNestedConstructorFromExtension() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/nestedConstructorFromExtension.kt"); + } + + @Test + @TestMetadata("nestedConstructorFromTopLevel.kt") + public void testNestedConstructorFromTopLevel() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/nestedConstructorFromTopLevel.kt"); + } + + @Test + @TestMetadata("noAmbiguityLocalVsTopLevel.kt") + public void testNoAmbiguityLocalVsTopLevel() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityLocalVsTopLevel.kt"); + } + + @Test + @TestMetadata("noAmbiguityMemberVsExtension.kt") + public void testNoAmbiguityMemberVsExtension() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsExtension.kt"); + } + + @Test + @TestMetadata("noAmbiguityMemberVsTopLevel.kt") + public void testNoAmbiguityMemberVsTopLevel() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsTopLevel.kt"); + } + + @Test + @TestMetadata("privateStaticAndPublicMember.kt") + public void testPrivateStaticAndPublicMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/privateStaticAndPublicMember.kt"); + } + + @Test + @TestMetadata("renameOnImport.kt") + public void testRenameOnImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/renameOnImport.kt"); + } + + @Test + @TestMetadata("topLevelFromClass.kt") + public void testTopLevelFromClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/topLevelFromClass.kt"); + } + + @Test + @TestMetadata("topLevelFromExtension.kt") + public void testTopLevelFromExtension() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/topLevelFromExtension.kt"); + } + + @Test + @TestMetadata("topLevelFromExtensionInClass.kt") + public void testTopLevelFromExtensionInClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/topLevelFromExtensionInClass.kt"); + } + + @Test + @TestMetadata("topLevelFromTopLevel.kt") + public void testTopLevelFromTopLevel() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/topLevelFromTopLevel.kt"); + } + + @Test + @TestMetadata("unresolved.kt") + public void testUnresolved() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/function/unresolved.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/callableReference/generic") + @TestDataPath("$PROJECT_ROOT") + public class Generic { + @Test + public void testAllFilesPresentInGeneric() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/generic"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("argumentAndReturnExpectedType.kt") + public void testArgumentAndReturnExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/generic/argumentAndReturnExpectedType.kt"); + } + + @Test + @TestMetadata("argumentExpectedType.kt") + public void testArgumentExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/generic/argumentExpectedType.kt"); + } + + @Test + @TestMetadata("dependOnArgumentType.kt") + public void testDependOnArgumentType() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/generic/dependOnArgumentType.kt"); + } + + @Test + @TestMetadata("expectedFunctionType.kt") + public void testExpectedFunctionType() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/generic/expectedFunctionType.kt"); + } + + @Test + @TestMetadata("explicitTypeArguments.kt") + public void testExplicitTypeArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/generic/explicitTypeArguments.kt"); + } + + @Test + @TestMetadata("genericExtensionFunction.kt") + public void testGenericExtensionFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/generic/genericExtensionFunction.kt"); + } + + @Test + @TestMetadata("genericFunctionsWithNullableTypes.kt") + public void testGenericFunctionsWithNullableTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/generic/genericFunctionsWithNullableTypes.kt"); + } + + @Test + @TestMetadata("kt10968.kt") + public void testKt10968() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/generic/kt10968.kt"); + } + + @Test + @TestMetadata("kt11075.kt") + public void testKt11075() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/generic/kt11075.kt"); + } + + @Test + @TestMetadata("kt12286.kt") + public void testKt12286() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/generic/kt12286.kt"); + } + + @Test + @TestMetadata("kt35896.kt") + public void testKt35896() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/generic/kt35896.kt"); + } + + @Test + @TestMetadata("kt7470.kt") + public void testKt7470() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/generic/kt7470.kt"); + } + + @Test + @TestMetadata("nestedCallWithOverload.kt") + public void testNestedCallWithOverload() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/generic/nestedCallWithOverload.kt"); + } + + @Test + @TestMetadata("resolutionGenericCallableWithNullableTypes.kt") + public void testResolutionGenericCallableWithNullableTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/generic/resolutionGenericCallableWithNullableTypes.kt"); + } + + @Test + @TestMetadata("resolutionWithGenericCallable.kt") + public void testResolutionWithGenericCallable() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/generic/resolutionWithGenericCallable.kt"); + } + + @Test + @TestMetadata("specialCalls.kt") + public void testSpecialCalls() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/generic/specialCalls.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/callableReference/property") + @TestDataPath("$PROJECT_ROOT") + public class Property { + @Test + @TestMetadata("abstractPropertyViaSubclasses.kt") + public void testAbstractPropertyViaSubclasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/property/abstractPropertyViaSubclasses.kt"); + } + + @Test + @TestMetadata("accessViaSubclass.kt") + public void testAccessViaSubclass() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/property/accessViaSubclass.kt"); + } + + @Test + public void testAllFilesPresentInProperty() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/property"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("backingField.kt") + public void testBackingField() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/property/backingField.kt"); + } + + @Test + @TestMetadata("classFromClass.kt") + public void testClassFromClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/property/classFromClass.kt"); + } + + @Test + @TestMetadata("extensionFromTopLevel.kt") + public void testExtensionFromTopLevel() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/property/extensionFromTopLevel.kt"); + } + + @Test + @TestMetadata("extensionPropertyOnNullable.kt") + public void testExtensionPropertyOnNullable() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/property/extensionPropertyOnNullable.kt"); + } + + @Test + @TestMetadata("extensionsSameName.kt") + public void testExtensionsSameName() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/property/extensionsSameName.kt"); + } + + @Test + @TestMetadata("genericClass.kt") + public void testGenericClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/property/genericClass.kt"); + } + + @Test + @TestMetadata("javaInstanceField.kt") + public void testJavaInstanceField() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/property/javaInstanceField.kt"); + } + + @Test + @TestMetadata("javaStaticFieldViaImport.kt") + public void testJavaStaticFieldViaImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/property/javaStaticFieldViaImport.kt"); + } + + @Test + @TestMetadata("kt7564.kt") + public void testKt7564() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/property/kt7564.kt"); + } + + @Test + @TestMetadata("kt7945_unrelatedClass.kt") + public void testKt7945_unrelatedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/property/kt7945_unrelatedClass.kt"); + } + + @Test + @TestMetadata("memberFromTopLevel.kt") + public void testMemberFromTopLevel() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/property/memberFromTopLevel.kt"); + } + + @Test + @TestMetadata("mutablePropertyViaDelegation.kt") + public void testMutablePropertyViaDelegation() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/property/mutablePropertyViaDelegation.kt"); + } + + @Test + @TestMetadata("propertyFromAbstractSuperClass.kt") + public void testPropertyFromAbstractSuperClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/property/propertyFromAbstractSuperClass.kt"); + } + + @Test + @TestMetadata("protectedVarFromClass.kt") + public void testProtectedVarFromClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/property/protectedVarFromClass.kt"); + } + + @Test + @TestMetadata("returnTypeDependentOnGenericProperty.kt") + public void testReturnTypeDependentOnGenericProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/property/returnTypeDependentOnGenericProperty.kt"); + } + + @Test + @TestMetadata("samePriorityForFunctionsAndProperties.kt") + public void testSamePriorityForFunctionsAndProperties() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/property/samePriorityForFunctionsAndProperties.kt"); + } + + @Test + @TestMetadata("topLevelFromTopLevel.kt") + public void testTopLevelFromTopLevel() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/property/topLevelFromTopLevel.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/callableReference/resolve") + @TestDataPath("$PROJECT_ROOT") + public class Resolve { + @Test + @TestMetadata("adaptedReferenceAgainstKCallable.kt") + public void testAdaptedReferenceAgainstKCallable() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/adaptedReferenceAgainstKCallable.kt"); + } + + @Test + @TestMetadata("adaptedReferenceAgainstReflectionType.kt") + public void testAdaptedReferenceAgainstReflectionType() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/adaptedReferenceAgainstReflectionType.kt"); + } + + @Test + public void testAllFilesPresentInResolve() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/resolve"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("ambiguityWhenNoApplicableCallableReferenceCandidate.kt") + public void testAmbiguityWhenNoApplicableCallableReferenceCandidate() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/ambiguityWhenNoApplicableCallableReferenceCandidate.kt"); + } + + @Test + @TestMetadata("ambiguityWithBoundExtensionReceiver.kt") + public void testAmbiguityWithBoundExtensionReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/ambiguityWithBoundExtensionReceiver.kt"); + } + + @Test + @TestMetadata("ambiguousWithVararg.kt") + public void testAmbiguousWithVararg() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/ambiguousWithVararg.kt"); + } + + @Test + @TestMetadata("applicableCallableReferenceFromDistantScope.kt") + public void testApplicableCallableReferenceFromDistantScope() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/applicableCallableReferenceFromDistantScope.kt"); + } + + @Test + @TestMetadata("byArgType.kt") + public void testByArgType() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/byArgType.kt"); + } + + @Test + @TestMetadata("byGenericArgType.kt") + public void testByGenericArgType() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/byGenericArgType.kt"); + } + + @Test + @TestMetadata("byValType.kt") + public void testByValType() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/byValType.kt"); + } + + @Test + @TestMetadata("callableReferenceToVarargWithOverload.kt") + public void testCallableReferenceToVarargWithOverload() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/callableReferenceToVarargWithOverload.kt"); + } + + @Test + @TestMetadata("chooseCallableReferenceDependingOnInferredReceiver.kt") + public void testChooseCallableReferenceDependingOnInferredReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/chooseCallableReferenceDependingOnInferredReceiver.kt"); + } + + @Test + @TestMetadata("chooseMostSpecificCandidateUsingCandidateDescriptorNotReflectionType.kt") + public void testChooseMostSpecificCandidateUsingCandidateDescriptorNotReflectionType() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/chooseMostSpecificCandidateUsingCandidateDescriptorNotReflectionType.kt"); + } + + @Test + @TestMetadata("chooseOuterCallBySingleCallableReference.kt") + public void testChooseOuterCallBySingleCallableReference() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/chooseOuterCallBySingleCallableReference.kt"); + } + + @Test + @TestMetadata("commonSupertypeFromReturnTypesOfCallableReference.kt") + public void testCommonSupertypeFromReturnTypesOfCallableReference() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/commonSupertypeFromReturnTypesOfCallableReference.kt"); + } + + @Test + @TestMetadata("compatibilityWarningOnReferenceAgainstReflectiveType.kt") + public void testCompatibilityWarningOnReferenceAgainstReflectiveType() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/compatibilityWarningOnReferenceAgainstReflectiveType.kt"); + } + + @Test + @TestMetadata("constructor.kt") + public void testConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/constructor.kt"); + } + + @Test + @TestMetadata("eagerAndPostponedCallableReferences.kt") + public void testEagerAndPostponedCallableReferences() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/eagerAndPostponedCallableReferences.kt"); + } + + @Test + @TestMetadata("eagerResolveOfSingleCallableReference.kt") + public void testEagerResolveOfSingleCallableReference() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/eagerResolveOfSingleCallableReference.kt"); + } + + @Test + @TestMetadata("innerClassConstructorOnOuterClassInstance.kt") + public void testInnerClassConstructorOnOuterClassInstance() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/innerClassConstructorOnOuterClassInstance.kt"); + } + + @Test + @TestMetadata("intersectionTypeOverloadWithWrongParameter.kt") + public void testIntersectionTypeOverloadWithWrongParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/intersectionTypeOverloadWithWrongParameter.kt"); + } + + @Test + @TestMetadata("kt10036.kt") + public void testKt10036() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/kt10036.kt"); + } + + @Test + @TestMetadata("kt10036_bound.kt") + public void testKt10036_bound() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/kt10036_bound.kt"); + } + + @Test + @TestMetadata("kt12338.kt") + public void testKt12338() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/kt12338.kt"); + } + + @Test + @TestMetadata("kt12751.kt") + public void testKt12751() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/kt12751.kt"); + } + + @Test + @TestMetadata("kt35887.kt") + public void testKt35887() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/kt35887.kt"); + } + + @Test + @TestMetadata("kt35887_simple.kt") + public void testKt35887_simple() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/kt35887_simple.kt"); + } + + @Test + @TestMetadata("kt35920.kt") + public void testKt35920() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/kt35920.kt"); + } + + @Test + @TestMetadata("kt8596.kt") + public void testKt8596() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/kt8596.kt"); + } + + @Test + @TestMetadata("kt9601.kt") + public void testKt9601() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/kt9601.kt"); + } + + @Test + @TestMetadata("moreSpecificAmbiguousExtensions.kt") + public void testMoreSpecificAmbiguousExtensions() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/moreSpecificAmbiguousExtensions.kt"); + } + + @Test + @TestMetadata("moreSpecificSimple.kt") + public void testMoreSpecificSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/moreSpecificSimple.kt"); + } + + @Test + @TestMetadata("multipleOutersAndMultipleCallableReferences.kt") + public void testMultipleOutersAndMultipleCallableReferences() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/multipleOutersAndMultipleCallableReferences.kt"); + } + + @Test + @TestMetadata("nestedReferenceCallAgainstExpectedType.kt") + public void testNestedReferenceCallAgainstExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/nestedReferenceCallAgainstExpectedType.kt"); + } + + @Test + @TestMetadata("noAmbiguityBetweenTopLevelAndMemberProperty.kt") + public void testNoAmbiguityBetweenTopLevelAndMemberProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/noAmbiguityBetweenTopLevelAndMemberProperty.kt"); + } + + @Test + @TestMetadata("noFakeDescriptorForObject.kt") + public void testNoFakeDescriptorForObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/noFakeDescriptorForObject.kt"); + } + + @Test + @TestMetadata("overloadAmbiguityForSimpleLastExpressionOfBlock.kt") + public void testOverloadAmbiguityForSimpleLastExpressionOfBlock() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/overloadAmbiguityForSimpleLastExpressionOfBlock.kt"); + } + + @Test + @TestMetadata("overloads.kt") + public void testOverloads() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/overloads.kt"); + } + + @Test + @TestMetadata("overloadsBound.kt") + public void testOverloadsBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/overloadsBound.kt"); + } + + @Test + @TestMetadata("overloadsMember.kt") + public void testOverloadsMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/overloadsMember.kt"); + } + + @Test + @TestMetadata("postponedResolveOfManyCallableReference.kt") + public void testPostponedResolveOfManyCallableReference() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/postponedResolveOfManyCallableReference.kt"); + } + + @Test + @TestMetadata("resolveCallableReferencesAfterAllSimpleArguments.kt") + public void testResolveCallableReferencesAfterAllSimpleArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/resolveCallableReferencesAfterAllSimpleArguments.kt"); + } + + @Test + @TestMetadata("resolveEqualsOperatorWithAnyExpectedType.kt") + public void testResolveEqualsOperatorWithAnyExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/resolveEqualsOperatorWithAnyExpectedType.kt"); + } + + @Test + @TestMetadata("resolveReferenceAgainstKFunctionAndKPrpoerty.kt") + public void testResolveReferenceAgainstKFunctionAndKPrpoerty() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/resolveReferenceAgainstKFunctionAndKPrpoerty.kt"); + } + + @Test + @TestMetadata("resolveTwoReferencesAgainstGenerics.kt") + public void testResolveTwoReferencesAgainstGenerics() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/resolveTwoReferencesAgainstGenerics.kt"); + } + + @Test + @TestMetadata("valVsFun.kt") + public void testValVsFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/valVsFun.kt"); + } + + @Test + @TestMetadata("withAs.kt") + public void testWithAs() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/withAs.kt"); + } + + @Test + @TestMetadata("withExtFun.kt") + public void testWithExtFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/withExtFun.kt"); + } + + @Test + @TestMetadata("withGenericFun.kt") + public void testWithGenericFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/withGenericFun.kt"); + } + + @Test + @TestMetadata("withPlaceholderTypes.kt") + public void testWithPlaceholderTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/withPlaceholderTypes.kt"); + } + + @Test + @TestMetadata("withVararg.kt") + public void testWithVararg() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/resolve/withVararg.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/callableReference/unsupported") + @TestDataPath("$PROJECT_ROOT") + public class Unsupported { + @Test + public void testAllFilesPresentInUnsupported() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/unsupported"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("callableReferenceToLocalVariable.kt") + public void testCallableReferenceToLocalVariable() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/unsupported/callableReferenceToLocalVariable.kt"); + } + + @Test + @TestMetadata("localVariable.kt") + public void testLocalVariable() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/unsupported/localVariable.kt"); + } + + @Test + @TestMetadata("localVariableWithSubstitution.kt") + public void testLocalVariableWithSubstitution() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/unsupported/localVariableWithSubstitution.kt"); + } + + @Test + @TestMetadata("parameterWithSubstitution.kt") + public void testParameterWithSubstitution() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/unsupported/parameterWithSubstitution.kt"); + } + + @Test + @TestMetadata("syntheticProperties.kt") + public void testSyntheticProperties() throws Exception { + runTest("compiler/testData/diagnostics/tests/callableReference/unsupported/syntheticProperties.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/cast") + @TestDataPath("$PROJECT_ROOT") + public class Cast { + @Test + public void testAllFilesPresentInCast() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cast"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("AsArray.kt") + public void testAsArray() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/AsArray.kt"); + } + + @Test + @TestMetadata("AsErasedError.kt") + public void testAsErasedError() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/AsErasedError.kt"); + } + + @Test + @TestMetadata("AsErasedFine.kt") + public void testAsErasedFine() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/AsErasedFine.kt"); + } + + @Test + @TestMetadata("AsErasedStar.kt") + public void testAsErasedStar() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/AsErasedStar.kt"); + } + + @Test + @TestMetadata("AsErasedWarning.kt") + public void testAsErasedWarning() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/AsErasedWarning.kt"); + } + + @Test + @TestMetadata("AsInBinaryUnary.kt") + public void testAsInBinaryUnary() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/AsInBinaryUnary.kt"); + } + + @Test + @TestMetadata("AsInBlockWithReturnType.kt") + public void testAsInBlockWithReturnType() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/AsInBlockWithReturnType.kt"); + } + + @Test + @TestMetadata("AsInCompoundAssignment.kt") + public void testAsInCompoundAssignment() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/AsInCompoundAssignment.kt"); + } + + @Test + @TestMetadata("AsInExpressionBody.kt") + public void testAsInExpressionBody() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/AsInExpressionBody.kt"); + } + + @Test + @TestMetadata("AsInPropertyAndPropertyAccessor.kt") + public void testAsInPropertyAndPropertyAccessor() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/AsInPropertyAndPropertyAccessor.kt"); + } + + @Test + @TestMetadata("AsNothing.kt") + public void testAsNothing() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/AsNothing.kt"); + } + + @Test + @TestMetadata("AsTypeAlias.kt") + public void testAsTypeAlias() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/AsTypeAlias.kt"); + } + + @Test + @TestMetadata("AsWithOtherParameter.kt") + public void testAsWithOtherParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/AsWithOtherParameter.kt"); + } + + @Test + @TestMetadata("checkCastToNullableType.kt") + public void testCheckCastToNullableType() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/checkCastToNullableType.kt"); + } + + @Test + @TestMetadata("constants.kt") + public void testConstants() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/constants.kt"); + } + + @Test + @TestMetadata("DowncastMap.kt") + public void testDowncastMap() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/DowncastMap.kt"); + } + + @Test + @TestMetadata("ExtensionAsNonExtension.kt") + public void testExtensionAsNonExtension() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/ExtensionAsNonExtension.kt"); + } + + @Test + @TestMetadata("FlexibleTargetType.kt") + public void testFlexibleTargetType() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/FlexibleTargetType.kt"); + } + + @Test + @TestMetadata("isAlwaysFalse.kt") + public void testIsAlwaysFalse() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/isAlwaysFalse.kt"); + } + + @Test + @TestMetadata("IsErasedAllowForDerivedWithOneSubstitutedAndOneSameGeneric.kt") + public void testIsErasedAllowForDerivedWithOneSubstitutedAndOneSameGeneric() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowForDerivedWithOneSubstitutedAndOneSameGeneric.kt"); + } + + @Test + @TestMetadata("IsErasedAllowForExactSupertypeCheck.kt") + public void testIsErasedAllowForExactSupertypeCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowForExactSupertypeCheck.kt"); + } + + @Test + @TestMetadata("IsErasedAllowForOverridenVarianceWithProjection.kt") + public void testIsErasedAllowForOverridenVarianceWithProjection() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowForOverridenVarianceWithProjection.kt"); + } + + @Test + @TestMetadata("IsErasedAllowForSupertypeCheckWithContrvariance.kt") + public void testIsErasedAllowForSupertypeCheckWithContrvariance() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowForSupertypeCheckWithContrvariance.kt"); + } + + @Test + @TestMetadata("IsErasedAllowForSupertypeCheckWithCovariance.kt") + public void testIsErasedAllowForSupertypeCheckWithCovariance() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowForSupertypeCheckWithCovariance.kt"); + } + + @Test + @TestMetadata("IsErasedAllowForTypeWithIrrelevantMixin.kt") + public void testIsErasedAllowForTypeWithIrrelevantMixin() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowForTypeWithIrrelevantMixin.kt"); + } + + @Test + @TestMetadata("IsErasedAllowForTypeWithTwoSameTypeSubstitutions.kt") + public void testIsErasedAllowForTypeWithTwoSameTypeSubstitutions() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowForTypeWithTwoSameTypeSubstitutions.kt"); + } + + @Test + @TestMetadata("IsErasedAllowForTypeWithoutTypeArguments.kt") + public void testIsErasedAllowForTypeWithoutTypeArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowForTypeWithoutTypeArguments.kt"); + } + + @Test + @TestMetadata("IsErasedAllowFromOut.kt") + public void testIsErasedAllowFromOut() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowFromOut.kt"); + } + + @Test + @TestMetadata("IsErasedAllowFromOut2.kt") + public void testIsErasedAllowFromOut2() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowFromOut2.kt"); + } + + @Test + @TestMetadata("IsErasedAllowFromOut3.kt") + public void testIsErasedAllowFromOut3() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowFromOut3.kt"); + } + + @Test + @TestMetadata("IsErasedAllowFromOutAtClass.kt") + public void testIsErasedAllowFromOutAtClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowFromOutAtClass.kt"); + } + + @Test + @TestMetadata("IsErasedAllowParameterSubtype.kt") + public void testIsErasedAllowParameterSubtype() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowParameterSubtype.kt"); + } + + @Test + @TestMetadata("IsErasedAllowSameClassParameter.kt") + public void testIsErasedAllowSameClassParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowSameClassParameter.kt"); + } + + @Test + @TestMetadata("IsErasedAllowSameParameterParameter.kt") + public void testIsErasedAllowSameParameterParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowSameParameterParameter.kt"); + } + + @Test + @TestMetadata("isErasedAnyAndStarred.kt") + public void testIsErasedAnyAndStarred() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/isErasedAnyAndStarred.kt"); + } + + @Test + @TestMetadata("IsErasedDisallowDifferentArgInvariantPosition.kt") + public void testIsErasedDisallowDifferentArgInvariantPosition() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedDisallowDifferentArgInvariantPosition.kt"); + } + + @Test + @TestMetadata("IsErasedDisallowForOverridenVariance.kt") + public void testIsErasedDisallowForOverridenVariance() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedDisallowForOverridenVariance.kt"); + } + + @Test + @TestMetadata("IsErasedDisallowForTypeWithConstraints.kt") + public void testIsErasedDisallowForTypeWithConstraints() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedDisallowForTypeWithConstraints.kt"); + } + + @Test + @TestMetadata("IsErasedDisallowFromAny.kt") + public void testIsErasedDisallowFromAny() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedDisallowFromAny.kt"); + } + + @Test + @TestMetadata("IsErasedDisallowFromIn.kt") + public void testIsErasedDisallowFromIn() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedDisallowFromIn.kt"); + } + + @Test + @TestMetadata("IsErasedDisallowFromOut.kt") + public void testIsErasedDisallowFromOut() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedDisallowFromOut.kt"); + } + + @Test + @TestMetadata("IsErasedDisallowFromOutAtClass.kt") + public void testIsErasedDisallowFromOutAtClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedDisallowFromOutAtClass.kt"); + } + + @Test + @TestMetadata("IsErasedDissallowForSubtypeMappedToTwoParamsWithFirstInvalid.kt") + public void testIsErasedDissallowForSubtypeMappedToTwoParamsWithFirstInvalid() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedDissallowForSubtypeMappedToTwoParamsWithFirstInvalid.kt"); + } + + @Test + @TestMetadata("IsErasedDissallowForSubtypeMappedToTwoParamsWithSecondInvalid.kt") + public void testIsErasedDissallowForSubtypeMappedToTwoParamsWithSecondInvalid() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedDissallowForSubtypeMappedToTwoParamsWithSecondInvalid.kt"); + } + + @Test + @TestMetadata("IsErasedNonGeneric.kt") + public void testIsErasedNonGeneric() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedNonGeneric.kt"); + } + + @Test + @TestMetadata("IsErasedNullableTasT.kt") + public void testIsErasedNullableTasT() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedNullableTasT.kt"); + } + + @Test + @TestMetadata("IsErasedStar.kt") + public void testIsErasedStar() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedStar.kt"); + } + + @Test + @TestMetadata("isErasedTAndStarred.kt") + public void testIsErasedTAndStarred() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/isErasedTAndStarred.kt"); + } + + @Test + @TestMetadata("IsErasedTasT.kt") + public void testIsErasedTasT() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedTasT.kt"); + } + + @Test + @TestMetadata("IsErasedToErrorType.kt") + public void testIsErasedToErrorType() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedToErrorType.kt"); + } + + @Test + @TestMetadata("isErasedUnrelatedAndStarred.kt") + public void testIsErasedUnrelatedAndStarred() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/isErasedUnrelatedAndStarred.kt"); + } + + @Test + @TestMetadata("IsErasedUpcastToNonReified.kt") + public void testIsErasedUpcastToNonReified() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsErasedUpcastToNonReified.kt"); + } + + @Test + @TestMetadata("IsForTypeWithComplexUpperBound.kt") + public void testIsForTypeWithComplexUpperBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsForTypeWithComplexUpperBound.kt"); + } + + @Test + @TestMetadata("IsRecursionSustainable.kt") + public void testIsRecursionSustainable() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsRecursionSustainable.kt"); + } + + @Test + @TestMetadata("IsTraits.kt") + public void testIsTraits() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsTraits.kt"); + } + + @Test + @TestMetadata("IsWithCycleUpperBounds.kt") + public void testIsWithCycleUpperBounds() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/IsWithCycleUpperBounds.kt"); + } + + @Test + @TestMetadata("kt15161.kt") + public void testKt15161() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/kt15161.kt"); + } + + @Test + @TestMetadata("kt47685.kt") + public void testKt47685() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/kt47685.kt"); + } + + @Test + @TestMetadata("kt614.kt") + public void testKt614() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/kt614.kt"); + } + + @Test + @TestMetadata("nothingAs.kt") + public void testNothingAs() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/nothingAs.kt"); + } + + @Test + @TestMetadata("NullableToNullable.kt") + public void testNullableToNullable() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/NullableToNullable.kt"); + } + + @Test + @TestMetadata("StableTypeForUselessCast.kt") + public void testStableTypeForUselessCast() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/StableTypeForUselessCast.kt"); + } + + @Test + @TestMetadata("UselessSafeCast.kt") + public void testUselessSafeCast() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/UselessSafeCast.kt"); + } + + @Test + @TestMetadata("WhenErasedDisallowFromAny.kt") + public void testWhenErasedDisallowFromAny() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/WhenErasedDisallowFromAny.kt"); + } + + @Test + @TestMetadata("WhenWithExpression.kt") + public void testWhenWithExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/WhenWithExpression.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/cast/bare") + @TestDataPath("$PROJECT_ROOT") + public class Bare { + @Test + public void testAllFilesPresentInBare() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cast/bare"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("AsNestedBare.kt") + public void testAsNestedBare() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/bare/AsNestedBare.kt"); + } + + @Test + @TestMetadata("AsNullable.kt") + public void testAsNullable() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/bare/AsNullable.kt"); + } + + @Test + @TestMetadata("AsNullableNotEnough.kt") + public void testAsNullableNotEnough() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/bare/AsNullableNotEnough.kt"); + } + + @Test + @TestMetadata("EitherAs.kt") + public void testEitherAs() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/bare/EitherAs.kt"); + } + + @Test + @TestMetadata("EitherIs.kt") + public void testEitherIs() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/bare/EitherIs.kt"); + } + + @Test + @TestMetadata("EitherNotIs.kt") + public void testEitherNotIs() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/bare/EitherNotIs.kt"); + } + + @Test + @TestMetadata("EitherSafeAs.kt") + public void testEitherSafeAs() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/bare/EitherSafeAs.kt"); + } + + @Test + @TestMetadata("EitherWhen.kt") + public void testEitherWhen() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/bare/EitherWhen.kt"); + } + + @Test + @TestMetadata("ErrorsInSubstitution.kt") + public void testErrorsInSubstitution() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/bare/ErrorsInSubstitution.kt"); + } + + @Test + @TestMetadata("FromErrorType.kt") + public void testFromErrorType() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/bare/FromErrorType.kt"); + } + + @Test + @TestMetadata("NullableAs.kt") + public void testNullableAs() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/bare/NullableAs.kt"); + } + + @Test + @TestMetadata("NullableAsNotEnough.kt") + public void testNullableAsNotEnough() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/bare/NullableAsNotEnough.kt"); + } + + @Test + @TestMetadata("NullableAsNullable.kt") + public void testNullableAsNullable() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/bare/NullableAsNullable.kt"); + } + + @Test + @TestMetadata("NullableAsNullableNotEnough.kt") + public void testNullableAsNullableNotEnough() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/bare/NullableAsNullableNotEnough.kt"); + } + + @Test + @TestMetadata("RedundantNullable.kt") + public void testRedundantNullable() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/bare/RedundantNullable.kt"); + } + + @Test + @TestMetadata("SupertypeChain.kt") + public void testSupertypeChain() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/bare/SupertypeChain.kt"); + } + + @Test + @TestMetadata("ToErrorType.kt") + public void testToErrorType() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/bare/ToErrorType.kt"); + } + + @Test + @TestMetadata("UnrelatedAs.kt") + public void testUnrelatedAs() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/bare/UnrelatedAs.kt"); + } + + @Test + @TestMetadata("UnrelatedColon.kt") + public void testUnrelatedColon() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/bare/UnrelatedColon.kt"); + } + + @Test + @TestMetadata("UnrelatedIs.kt") + public void testUnrelatedIs() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/bare/UnrelatedIs.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/cast/neverSucceeds") + @TestDataPath("$PROJECT_ROOT") + public class NeverSucceeds { + @Test + public void testAllFilesPresentInNeverSucceeds() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cast/neverSucceeds"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("CastToNotNullSuper.kt") + public void testCastToNotNullSuper() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/neverSucceeds/CastToNotNullSuper.kt"); + } + + @Test + @TestMetadata("MappedDirect.kt") + public void testMappedDirect() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/neverSucceeds/MappedDirect.kt"); + } + + @Test + @TestMetadata("MappedSubtypes.kt") + public void testMappedSubtypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/neverSucceeds/MappedSubtypes.kt"); + } + + @Test + @TestMetadata("NoGenericsRelated.kt") + public void testNoGenericsRelated() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/neverSucceeds/NoGenericsRelated.kt"); + } + + @Test + @TestMetadata("NoGenericsUnrelated.kt") + public void testNoGenericsUnrelated() throws Exception { + runTest("compiler/testData/diagnostics/tests/cast/neverSucceeds/NoGenericsUnrelated.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/checkArguments") + @TestDataPath("$PROJECT_ROOT") + public class CheckArguments { + @Test + public void testAllFilesPresentInCheckArguments() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/checkArguments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("arrayAccessSet.kt") + public void testArrayAccessSet() throws Exception { + runTest("compiler/testData/diagnostics/tests/checkArguments/arrayAccessSet.kt"); + } + + @Test + @TestMetadata("arrayAccessSetNotEnoughArgs.kt") + public void testArrayAccessSetNotEnoughArgs() throws Exception { + runTest("compiler/testData/diagnostics/tests/checkArguments/arrayAccessSetNotEnoughArgs.kt"); + } + + @Test + @TestMetadata("arrayAccessSetTooManyArgs.kt") + public void testArrayAccessSetTooManyArgs() throws Exception { + runTest("compiler/testData/diagnostics/tests/checkArguments/arrayAccessSetTooManyArgs.kt"); + } + + @Test + @TestMetadata("booleanExpressions.kt") + public void testBooleanExpressions() throws Exception { + runTest("compiler/testData/diagnostics/tests/checkArguments/booleanExpressions.kt"); + } + + @Test + @TestMetadata("kt17691.kt") + public void testKt17691() throws Exception { + runTest("compiler/testData/diagnostics/tests/checkArguments/kt17691.kt"); + } + + @Test + @TestMetadata("kt17691WithEnabledFeature.kt") + public void testKt17691WithEnabledFeature() throws Exception { + runTest("compiler/testData/diagnostics/tests/checkArguments/kt17691WithEnabledFeature.kt"); + } + + @Test + @TestMetadata("kt1897_diagnostic_part.kt") + public void testKt1897_diagnostic_part() throws Exception { + runTest("compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.kt"); + } + + @Test + @TestMetadata("kt1940.kt") + public void testKt1940() throws Exception { + runTest("compiler/testData/diagnostics/tests/checkArguments/kt1940.kt"); + } + + @Test + @TestMetadata("kt49276.kt") + public void testKt49276() throws Exception { + runTest("compiler/testData/diagnostics/tests/checkArguments/kt49276.kt"); + } + + @Test + @TestMetadata("kt49276Disabled.kt") + public void testKt49276Disabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/checkArguments/kt49276Disabled.kt"); + } + + @Test + @TestMetadata("kt49276Error.kt") + public void testKt49276Error() throws Exception { + runTest("compiler/testData/diagnostics/tests/checkArguments/kt49276Error.kt"); + } + + @Test + @TestMetadata("kt51062.kt") + public void testKt51062() throws Exception { + runTest("compiler/testData/diagnostics/tests/checkArguments/kt51062.kt"); + } + + @Test + @TestMetadata("overloadedFunction.kt") + public void testOverloadedFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/checkArguments/overloadedFunction.kt"); + } + + @Test + @TestMetadata("SpreadVarargs.kt") + public void testSpreadVarargs() throws Exception { + runTest("compiler/testData/diagnostics/tests/checkArguments/SpreadVarargs.kt"); + } + + @Test + @TestMetadata("twoLambdasFunction.kt") + public void testTwoLambdasFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/checkArguments/twoLambdasFunction.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/classLiteral") + @TestDataPath("$PROJECT_ROOT") + public class ClassLiteral { + @Test + public void testAllFilesPresentInClassLiteral() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/classLiteral"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("arrays.kt") + public void testArrays() throws Exception { + runTest("compiler/testData/diagnostics/tests/classLiteral/arrays.kt"); + } + + @Test + @TestMetadata("classAndObjectLiteralType.kt") + public void testClassAndObjectLiteralType() throws Exception { + runTest("compiler/testData/diagnostics/tests/classLiteral/classAndObjectLiteralType.kt"); + } + + @Test + @TestMetadata("classLiteralType.kt") + public void testClassLiteralType() throws Exception { + runTest("compiler/testData/diagnostics/tests/classLiteral/classLiteralType.kt"); + } + + @Test + @TestMetadata("expressionWithNullableType.kt") + public void testExpressionWithNullableType() throws Exception { + runTest("compiler/testData/diagnostics/tests/classLiteral/expressionWithNullableType.kt"); + } + + @Test + @TestMetadata("genericArrays.kt") + public void testGenericArrays() throws Exception { + runTest("compiler/testData/diagnostics/tests/classLiteral/genericArrays.kt"); + } + + @Test + @TestMetadata("genericClasses.kt") + public void testGenericClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/classLiteral/genericClasses.kt"); + } + + @Test + @TestMetadata("inAnnotationArguments.kt") + public void testInAnnotationArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/classLiteral/inAnnotationArguments.kt"); + } + + @Test + @TestMetadata("inAnnotationArguments_noTypeParams.kt") + public void testInAnnotationArguments_noTypeParams() throws Exception { + runTest("compiler/testData/diagnostics/tests/classLiteral/inAnnotationArguments_noTypeParams.kt"); + } + + @Test + @TestMetadata("integerValueType.kt") + public void testIntegerValueType() throws Exception { + runTest("compiler/testData/diagnostics/tests/classLiteral/integerValueType.kt"); + } + + @Test + @TestMetadata("nonClassesOnLHS.kt") + public void testNonClassesOnLHS() throws Exception { + runTest("compiler/testData/diagnostics/tests/classLiteral/nonClassesOnLHS.kt"); + } + + @Test + @TestMetadata("qualifiedClassLiteral.kt") + public void testQualifiedClassLiteral() throws Exception { + runTest("compiler/testData/diagnostics/tests/classLiteral/qualifiedClassLiteral.kt"); + } + + @Test + @TestMetadata("simpleClassLiteral.kt") + public void testSimpleClassLiteral() throws Exception { + runTest("compiler/testData/diagnostics/tests/classLiteral/simpleClassLiteral.kt"); + } + + @Test + @TestMetadata("smartCast.kt") + public void testSmartCast() throws Exception { + runTest("compiler/testData/diagnostics/tests/classLiteral/smartCast.kt"); + } + + @Test + @TestMetadata("typealiases.kt") + public void testTypealiases() throws Exception { + runTest("compiler/testData/diagnostics/tests/classLiteral/typealiases.kt"); + } + + @Test + @TestMetadata("unresolvedClass.kt") + public void testUnresolvedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/classLiteral/unresolvedClass.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/classObjects") + @TestDataPath("$PROJECT_ROOT") + public class ClassObjects { + @Test + public void testAllFilesPresentInClassObjects() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/classObjects"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("builtInClassObjects.kt") + public void testBuiltInClassObjects() throws Exception { + runTest("compiler/testData/diagnostics/tests/classObjects/builtInClassObjects.kt"); + } + + @Test + @TestMetadata("ClassObjectCannotAccessClassFields.kt") + public void testClassObjectCannotAccessClassFields() throws Exception { + runTest("compiler/testData/diagnostics/tests/classObjects/ClassObjectCannotAccessClassFields.kt"); + } + + @Test + @TestMetadata("classObjectHeader.kt") + public void testClassObjectHeader() throws Exception { + runTest("compiler/testData/diagnostics/tests/classObjects/classObjectHeader.kt"); + } + + @Test + @TestMetadata("classObjectInLocalClass.kt") + public void testClassObjectInLocalClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/classObjects/classObjectInLocalClass.kt"); + } + + @Test + @TestMetadata("classObjectRedeclaration.kt") + public void testClassObjectRedeclaration() throws Exception { + runTest("compiler/testData/diagnostics/tests/classObjects/classObjectRedeclaration.kt"); + } + + @Test + @TestMetadata("ClassObjectVisibility.kt") + public void testClassObjectVisibility() throws Exception { + runTest("compiler/testData/diagnostics/tests/classObjects/ClassObjectVisibility.kt"); + } + + @Test + @TestMetadata("ClassObjects.kt") + public void testClassObjects() throws Exception { + runTest("compiler/testData/diagnostics/tests/classObjects/ClassObjects.kt"); + } + + @Test + @TestMetadata("classWithFunctionSupertype_after.kt") + public void testClassWithFunctionSupertype_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/classObjects/classWithFunctionSupertype_after.kt"); + } + + @Test + @TestMetadata("classWithFunctionSupertype_before.kt") + public void testClassWithFunctionSupertype_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/classObjects/classWithFunctionSupertype_before.kt"); + } + + @Test + @TestMetadata("companionObjectOfPrivateClassVisibility.kt") + public void testCompanionObjectOfPrivateClassVisibility() throws Exception { + runTest("compiler/testData/diagnostics/tests/classObjects/companionObjectOfPrivateClassVisibility.kt"); + } + + @Test + @TestMetadata("importClassInClassObject.kt") + public void testImportClassInClassObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/classObjects/importClassInClassObject.kt"); + } + + @Test + @TestMetadata("InnerClassAccessThroughClassObject.kt") + public void testInnerClassAccessThroughClassObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/classObjects/InnerClassAccessThroughClassObject.kt"); + } + + @Test + @TestMetadata("InnerClassAccessThroughEnum_after.kt") + public void testInnerClassAccessThroughEnum_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/classObjects/InnerClassAccessThroughEnum_after.kt"); + } + + @Test + @TestMetadata("InnerClassAccessThroughEnum_before.kt") + public void testInnerClassAccessThroughEnum_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/classObjects/InnerClassAccessThroughEnum_before.kt"); + } + + @Test + @TestMetadata("InnerClassClassObject.kt") + public void testInnerClassClassObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/classObjects/InnerClassClassObject.kt"); + } + + @Test + @TestMetadata("invisibleClassObjects.kt") + public void testInvisibleClassObjects() throws Exception { + runTest("compiler/testData/diagnostics/tests/classObjects/invisibleClassObjects.kt"); + } + + @Test + @TestMetadata("kt3866.kt") + public void testKt3866() throws Exception { + runTest("compiler/testData/diagnostics/tests/classObjects/kt3866.kt"); + } + + @Test + @TestMetadata("multipleDissallowedDefaultObjects.kt") + public void testMultipleDissallowedDefaultObjects() throws Exception { + runTest("compiler/testData/diagnostics/tests/classObjects/multipleDissallowedDefaultObjects.kt"); + } + + @Test + @TestMetadata("nestedClassInPrivateClassObject.kt") + public void testNestedClassInPrivateClassObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/classObjects/nestedClassInPrivateClassObject.kt"); + } + + @Test + @TestMetadata("resolveFunctionInsideClassObject.kt") + public void testResolveFunctionInsideClassObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/classObjects/resolveFunctionInsideClassObject.kt"); + } + + @Test + @TestMetadata("selfCallsInCompanionSuperConstructor_error.kt") + public void testSelfCallsInCompanionSuperConstructor_error() throws Exception { + runTest("compiler/testData/diagnostics/tests/classObjects/selfCallsInCompanionSuperConstructor_error.kt"); + } + + @Test + @TestMetadata("selfCallsInCompanionSuperConstructor_warning.kt") + public void testSelfCallsInCompanionSuperConstructor_warning() throws Exception { + runTest("compiler/testData/diagnostics/tests/classObjects/selfCallsInCompanionSuperConstructor_warning.kt"); + } + + @Test + @TestMetadata("typeParametersInAnnonymousObject.kt") + public void testTypeParametersInAnnonymousObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/classObjects/typeParametersInAnnonymousObject.kt"); + } + + @Test + @TestMetadata("typeParametersInAnnonymousObject_after.kt") + public void testTypeParametersInAnnonymousObject_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/classObjects/typeParametersInAnnonymousObject_after.kt"); + } + + @Test + @TestMetadata("typeParametersInObject.kt") + public void testTypeParametersInObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/classObjects/typeParametersInObject.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/collectionLiterals") + @TestDataPath("$PROJECT_ROOT") + public class CollectionLiterals { + @Test + public void testAllFilesPresentInCollectionLiterals() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/collectionLiterals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("argumentsOfAnnotation.kt") + public void testArgumentsOfAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotation.kt"); + } + + @Test + @TestMetadata("argumentsOfAnnotationWithKClass.kt") + public void testArgumentsOfAnnotationWithKClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotationWithKClass.kt"); + } + + @Test + @TestMetadata("basicCollectionLiterals.kt") + public void testBasicCollectionLiterals() throws Exception { + runTest("compiler/testData/diagnostics/tests/collectionLiterals/basicCollectionLiterals.kt"); + } + + @Test + @TestMetadata("collectionLiteralsAsPrimitiveArrays.kt") + public void testCollectionLiteralsAsPrimitiveArrays() throws Exception { + runTest("compiler/testData/diagnostics/tests/collectionLiterals/collectionLiteralsAsPrimitiveArrays.kt"); + } + + @Test + @TestMetadata("collectionLiteralsOutsideOfAnnotations.kt") + public void testCollectionLiteralsOutsideOfAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/collectionLiterals/collectionLiteralsOutsideOfAnnotations.kt"); + } + + @Test + @TestMetadata("collectionLiteralsWithVarargs.kt") + public void testCollectionLiteralsWithVarargs() throws Exception { + runTest("compiler/testData/diagnostics/tests/collectionLiterals/collectionLiteralsWithVarargs.kt"); + } + + @Test + @TestMetadata("defaultValuesInAnnotation.kt") + public void testDefaultValuesInAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/tests/collectionLiterals/defaultValuesInAnnotation.kt"); + } + + @Test + @TestMetadata("defaultValuesWithConstantsInAnnotation.kt") + public void testDefaultValuesWithConstantsInAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/tests/collectionLiterals/defaultValuesWithConstantsInAnnotation.kt"); + } + + @Test + @TestMetadata("kt34515.kt") + public void testKt34515() throws Exception { + runTest("compiler/testData/diagnostics/tests/collectionLiterals/kt34515.kt"); + } + + @Test + @TestMetadata("noCollectionLiterals.kt") + public void testNoCollectionLiterals() throws Exception { + runTest("compiler/testData/diagnostics/tests/collectionLiterals/noCollectionLiterals.kt"); + } + + @Test + @TestMetadata("resolveToFunctionFromBuiltIns.kt") + public void testResolveToFunctionFromBuiltIns() throws Exception { + runTest("compiler/testData/diagnostics/tests/collectionLiterals/resolveToFunctionFromBuiltIns.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/constantEvaluator") + @TestDataPath("$PROJECT_ROOT") + public class ConstantEvaluator { + @Test + public void testAllFilesPresentInConstantEvaluator() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/constantEvaluator"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/constantEvaluator/constant") + @TestDataPath("$PROJECT_ROOT") + public class Constant { + @Test + public void testAllFilesPresentInConstant() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/constantEvaluator/constant"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("classObjectProperty.kt") + public void testClassObjectProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/constant/classObjectProperty.kt"); + } + + @Test + @TestMetadata("compareTo.kt") + public void testCompareTo() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/constant/compareTo.kt"); + } + + @Test + @TestMetadata("differentTypes.kt") + public void testDifferentTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/constant/differentTypes.kt"); + } + + @Test + @TestMetadata("divideByZero.kt") + public void testDivideByZero() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/constant/divideByZero.kt"); + } + + @Test + @TestMetadata("duplicateLabelWithNonTrivialCondition_disabled.kt") + public void testDuplicateLabelWithNonTrivialCondition_disabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/constant/duplicateLabelWithNonTrivialCondition_disabled.kt"); + } + + @Test + @TestMetadata("duplicateLabelWithNonTrivialCondition_enabled.kt") + public void testDuplicateLabelWithNonTrivialCondition_enabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/constant/duplicateLabelWithNonTrivialCondition_enabled.kt"); + } + + @Test + @TestMetadata("equals.kt") + public void testEquals() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/constant/equals.kt"); + } + + @Test + @TestMetadata("exceptionWhenEvaluate.kt") + public void testExceptionWhenEvaluate() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/constant/exceptionWhenEvaluate.kt"); + } + + @Test + @TestMetadata("finalProperty.kt") + public void testFinalProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/constant/finalProperty.kt"); + } + + @Test + @TestMetadata("float.kt") + public void testFloat() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/constant/float.kt"); + } + + @Test + @TestMetadata("floatsAndDoubles.kt") + public void testFloatsAndDoubles() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/constant/floatsAndDoubles.kt"); + } + + @Test + @TestMetadata("integer.kt") + public void testInteger() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/constant/integer.kt"); + } + + @Test + @TestMetadata("integerOperations.kt") + public void testIntegerOperations() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/constant/integerOperations.kt"); + } + + @Test + @TestMetadata("integers.kt") + public void testIntegers() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/constant/integers.kt"); + } + + @Test + @TestMetadata("invAsCompileTimeCall.kt") + public void testInvAsCompileTimeCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/constant/invAsCompileTimeCall.kt"); + } + + @Test + @TestMetadata("localVal.kt") + public void testLocalVal() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/constant/localVal.kt"); + } + + @Test + @TestMetadata("localVar.kt") + public void testLocalVar() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/constant/localVar.kt"); + } + + @Test + @TestMetadata("nonFinalProperty.kt") + public void testNonFinalProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/constant/nonFinalProperty.kt"); + } + + @Test + @TestMetadata("objectProperty.kt") + public void testObjectProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/constant/objectProperty.kt"); + } + + @Test + @TestMetadata("strings.kt") + public void testStrings() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/constant/strings.kt"); + } + + @Test + @TestMetadata("topLevelVal.kt") + public void testTopLevelVal() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/constant/topLevelVal.kt"); + } + + @Test + @TestMetadata("topLevelVar.kt") + public void testTopLevelVar() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/constant/topLevelVar.kt"); + } + + @Test + @TestMetadata("unaryMinusIndepWoExpType.kt") + public void testUnaryMinusIndepWoExpType() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/constant/unaryMinusIndepWoExpType.kt"); + } + + @Test + @TestMetadata("unaryMinusIndependentExpType.kt") + public void testUnaryMinusIndependentExpType() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/constant/unaryMinusIndependentExpType.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/constantEvaluator/isPure") + @TestDataPath("$PROJECT_ROOT") + public class IsPure { + @Test + public void testAllFilesPresentInIsPure() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/constantEvaluator/isPure"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("innerToType.kt") + public void testInnerToType() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/isPure/innerToType.kt"); + } + + @Test + @TestMetadata("namedConstants.kt") + public void testNamedConstants() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/isPure/namedConstants.kt"); + } + + @Test + @TestMetadata("toType.kt") + public void testToType() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/isPure/toType.kt"); + } + + @Test + @TestMetadata("unaryMinusIndepWoExpType.kt") + public void testUnaryMinusIndepWoExpType() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/isPure/unaryMinusIndepWoExpType.kt"); + } + + @Test + @TestMetadata("unaryMinusIndependentExpType.kt") + public void testUnaryMinusIndependentExpType() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/isPure/unaryMinusIndependentExpType.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/constantEvaluator/usesVariableAsConstant") + @TestDataPath("$PROJECT_ROOT") + public class UsesVariableAsConstant { + @Test + public void testAllFilesPresentInUsesVariableAsConstant() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/constantEvaluator/usesVariableAsConstant"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("binaryTypes.kt") + public void testBinaryTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/usesVariableAsConstant/binaryTypes.kt"); + } + + @Test + @TestMetadata("NamedConstants.kt") + public void testNamedConstants() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/usesVariableAsConstant/NamedConstants.kt"); + } + + @Test + @TestMetadata("OtherTypes.kt") + public void testOtherTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/usesVariableAsConstant/OtherTypes.kt"); + } + + @Test + @TestMetadata("simpleTypes.kt") + public void testSimpleTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/constantEvaluator/usesVariableAsConstant/simpleTypes.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/constructorConsistency") + @TestDataPath("$PROJECT_ROOT") + public class ConstructorConsistency { + @Test + @TestMetadata("afterInitialization.kt") + public void testAfterInitialization() throws Exception { + runTest("compiler/testData/diagnostics/tests/constructorConsistency/afterInitialization.kt"); + } + + @Test + @TestMetadata("aliencall.kt") + public void testAliencall() throws Exception { + runTest("compiler/testData/diagnostics/tests/constructorConsistency/aliencall.kt"); + } + + @Test + public void testAllFilesPresentInConstructorConsistency() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/constructorConsistency"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("assignment.kt") + public void testAssignment() throws Exception { + runTest("compiler/testData/diagnostics/tests/constructorConsistency/assignment.kt"); + } + + @Test + @TestMetadata("backing.kt") + public void testBacking() throws Exception { + runTest("compiler/testData/diagnostics/tests/constructorConsistency/backing.kt"); + } + + @Test + @TestMetadata("basic.kt") + public void testBasic() throws Exception { + runTest("compiler/testData/diagnostics/tests/constructorConsistency/basic.kt"); + } + + @Test + @TestMetadata("companion.kt") + public void testCompanion() throws Exception { + runTest("compiler/testData/diagnostics/tests/constructorConsistency/companion.kt"); + } + + @Test + @TestMetadata("comparison.kt") + public void testComparison() throws Exception { + runTest("compiler/testData/diagnostics/tests/constructorConsistency/comparison.kt"); + } + + @Test + @TestMetadata("delegate.kt") + public void testDelegate() throws Exception { + runTest("compiler/testData/diagnostics/tests/constructorConsistency/delegate.kt"); + } + + @Test + @TestMetadata("derived.kt") + public void testDerived() throws Exception { + runTest("compiler/testData/diagnostics/tests/constructorConsistency/derived.kt"); + } + + @Test + @TestMetadata("derivedProperty.kt") + public void testDerivedProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/constructorConsistency/derivedProperty.kt"); + } + + @Test + @TestMetadata("getset.kt") + public void testGetset() throws Exception { + runTest("compiler/testData/diagnostics/tests/constructorConsistency/getset.kt"); + } + + @Test + @TestMetadata("init.kt") + public void testInit() throws Exception { + runTest("compiler/testData/diagnostics/tests/constructorConsistency/init.kt"); + } + + @Test + @TestMetadata("initializerWithSecondaryConstructor.kt") + public void testInitializerWithSecondaryConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/constructorConsistency/initializerWithSecondaryConstructor.kt"); + } + + @Test + @TestMetadata("initwithgetter.kt") + public void testInitwithgetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/constructorConsistency/initwithgetter.kt"); + } + + @Test + @TestMetadata("inspection.kt") + public void testInspection() throws Exception { + runTest("compiler/testData/diagnostics/tests/constructorConsistency/inspection.kt"); + } + + @Test + @TestMetadata("lambdaInObject.kt") + public void testLambdaInObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/constructorConsistency/lambdaInObject.kt"); + } + + @Test + @TestMetadata("lateInit.kt") + public void testLateInit() throws Exception { + runTest("compiler/testData/diagnostics/tests/constructorConsistency/lateInit.kt"); + } + + @Test + @TestMetadata("localObject.kt") + public void testLocalObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/constructorConsistency/localObject.kt"); + } + + @Test + @TestMetadata("multipleAreNull.kt") + public void testMultipleAreNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/constructorConsistency/multipleAreNull.kt"); + } + + @Test + @TestMetadata("nobacking.kt") + public void testNobacking() throws Exception { + runTest("compiler/testData/diagnostics/tests/constructorConsistency/nobacking.kt"); + } + + @Test + @TestMetadata("open.kt") + public void testOpen() throws Exception { + runTest("compiler/testData/diagnostics/tests/constructorConsistency/open.kt"); + } + + @Test + @TestMetadata("openProperty.kt") + public void testOpenProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/constructorConsistency/openProperty.kt"); + } + + @Test + @TestMetadata("outer.kt") + public void testOuter() throws Exception { + runTest("compiler/testData/diagnostics/tests/constructorConsistency/outer.kt"); + } + + @Test + @TestMetadata("property.kt") + public void testProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/constructorConsistency/property.kt"); + } + + @Test + @TestMetadata("propertyAccess.kt") + public void testPropertyAccess() throws Exception { + runTest("compiler/testData/diagnostics/tests/constructorConsistency/propertyAccess.kt"); + } + + @Test + @TestMetadata("twoSecondaryConstructors.kt") + public void testTwoSecondaryConstructors() throws Exception { + runTest("compiler/testData/diagnostics/tests/constructorConsistency/twoSecondaryConstructors.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis") + @TestDataPath("$PROJECT_ROOT") + public class ControlFlowAnalysis { + @Test + @TestMetadata("accessValueParameterInDefaultValue_after.kt") + public void testAccessValueParameterInDefaultValue_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/accessValueParameterInDefaultValue_after.kt"); + } + + @Test + @TestMetadata("accessValueParameterInDefaultValue_before.kt") + public void testAccessValueParameterInDefaultValue_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/accessValueParameterInDefaultValue_before.kt"); + } + + @Test + public void testAllFilesPresentInControlFlowAnalysis() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("assignedInFinally.kt") + public void testAssignedInFinally() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/assignedInFinally.kt"); + } + + @Test + @TestMetadata("assignedInIfElse.kt") + public void testAssignedInIfElse() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/assignedInIfElse.kt"); + } + + @Test + @TestMetadata("assignedInTryWithCatch.kt") + public void testAssignedInTryWithCatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/assignedInTryWithCatch.kt"); + } + + @Test + @TestMetadata("assignedInTryWithoutCatch.kt") + public void testAssignedInTryWithoutCatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/assignedInTryWithoutCatch.kt"); + } + + @Test + @TestMetadata("assignmentInLocalsInConstructor.kt") + public void testAssignmentInLocalsInConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/assignmentInLocalsInConstructor.kt"); + } + + @Test + @TestMetadata("assignmentOfSyntheticVarWithInconsistentNullability.kt") + public void testAssignmentOfSyntheticVarWithInconsistentNullability() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/assignmentOfSyntheticVarWithInconsistentNullability.kt"); + } + + @Test + @TestMetadata("backingFieldInsideGetter_after.kt") + public void testBackingFieldInsideGetter_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/backingFieldInsideGetter_after.kt"); + } + + @Test + @TestMetadata("backingFieldInsideGetter_before.kt") + public void testBackingFieldInsideGetter_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/backingFieldInsideGetter_before.kt"); + } + + @Test + @TestMetadata("breakContinueInTryFinally.kt") + public void testBreakContinueInTryFinally() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/breakContinueInTryFinally.kt"); + } + + @Test + @TestMetadata("breakContinueInTryFinallyInLoop.kt") + public void testBreakContinueInTryFinallyInLoop() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/breakContinueInTryFinallyInLoop.kt"); + } + + @Test + @TestMetadata("breakContinueNoinline.kt") + public void testBreakContinueNoinline() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/breakContinueNoinline.kt"); + } + + @Test + @TestMetadata("breakInLambdaPassedToDirectInvoke.kt") + public void testBreakInLambdaPassedToDirectInvoke() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/breakInLambdaPassedToDirectInvoke.kt"); + } + + @Test + @TestMetadata("breakInsideLocal.kt") + public void testBreakInsideLocal() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/breakInsideLocal.kt"); + } + + @Test + @TestMetadata("breakOrContinueInLoopCondition.kt") + public void testBreakOrContinueInLoopCondition() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/breakOrContinueInLoopCondition.kt"); + } + + @Test + @TestMetadata("capturingUninitializedVariableInNonInPlaceLambda.kt") + public void testCapturingUninitializedVariableInNonInPlaceLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/capturingUninitializedVariableInNonInPlaceLambda.kt"); + } + + @Test + @TestMetadata("checkInnerLocalDeclarations.kt") + public void testCheckInnerLocalDeclarations() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/checkInnerLocalDeclarations.kt"); + } + + @Test + @TestMetadata("checkPropertyAccessor.kt") + public void testCheckPropertyAccessor() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/checkPropertyAccessor.kt"); + } + + @Test + @TestMetadata("constructorPropertyInterdependence.kt") + public void testConstructorPropertyInterdependence() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/constructorPropertyInterdependence.kt"); + } + + @Test + @TestMetadata("definiteReturnInWhen.kt") + public void testDefiniteReturnInWhen() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturnInWhen.kt"); + } + + @Test + @TestMetadata("delegatedMemberProperyWriteInInit.kt") + public void testDelegatedMemberProperyWriteInInit() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/delegatedMemberProperyWriteInInit.kt"); + } + + @Test + @TestMetadata("delegatedPropertyEarlyAccess.kt") + public void testDelegatedPropertyEarlyAccess() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/delegatedPropertyEarlyAccess.kt"); + } + + @Test + @TestMetadata("doWhileAssignment.kt") + public void testDoWhileAssignment() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/doWhileAssignment.kt"); + } + + @Test + @TestMetadata("doWhileNotDefined.kt") + public void testDoWhileNotDefined() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/doWhileNotDefined.kt"); + } + + @Test + @TestMetadata("elvisNotProcessed.kt") + public void testElvisNotProcessed() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/elvisNotProcessed.kt"); + } + + @Test + @TestMetadata("enumCompanionInterdependence.kt") + public void testEnumCompanionInterdependence() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/enumCompanionInterdependence.kt"); + } + + @Test + @TestMetadata("enumInterdependence.kt") + public void testEnumInterdependence() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/enumInterdependence.kt"); + } + + @Test + @TestMetadata("fieldAsClassDelegate.kt") + public void testFieldAsClassDelegate() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldAsClassDelegate.kt"); + } + + @Test + @TestMetadata("fieldInitialization.kt") + public void testFieldInitialization() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldInitialization.kt"); + } + + @Test + @TestMetadata("infiniteLoops.kt") + public void testInfiniteLoops() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/infiniteLoops.kt"); + } + + @Test + @TestMetadata("initializationInLambda.kt") + public void testInitializationInLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLambda.kt"); + } + + @Test + @TestMetadata("initializationInLocalClass.kt") + public void testInitializationInLocalClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalClass.kt"); + } + + @Test + @TestMetadata("initializationInLocalFun.kt") + public void testInitializationInLocalFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalFun.kt"); + } + + @Test + @TestMetadata("initializationInLocalViaExplicitThis_after.kt") + public void testInitializationInLocalViaExplicitThis_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalViaExplicitThis_after.kt"); + } + + @Test + @TestMetadata("initializationInLocalViaExplicitThis_before.kt") + public void testInitializationInLocalViaExplicitThis_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalViaExplicitThis_before.kt"); + } + + @Test + @TestMetadata("inlinedBreakContinueFeatureDisabled.kt") + public void testInlinedBreakContinueFeatureDisabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/inlinedBreakContinueFeatureDisabled.kt"); + } + + @Test + @TestMetadata("kt1001.kt") + public void testKt1001() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1001.kt"); + } + + @Test + @TestMetadata("kt1027.kt") + public void testKt1027() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1027.kt"); + } + + @Test + @TestMetadata("kt1066.kt") + public void testKt1066() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1066.kt"); + } + + @Test + @TestMetadata("kt10805.kt") + public void testKt10805() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt10805.kt"); + } + + @Test + @TestMetadata("kt10823.kt") + public void testKt10823() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt10823.kt"); + } + + @Test + @TestMetadata("kt1156.kt") + public void testKt1156() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1156.kt"); + } + + @Test + @TestMetadata("kt1185enums.kt") + public void testKt1185enums() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1185enums.kt"); + } + + @Test + @TestMetadata("kt1189.kt") + public void testKt1189() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1189.kt"); + } + + @Test + @TestMetadata("kt1191.kt") + public void testKt1191() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1191.kt"); + } + + @Test + @TestMetadata("kt1219.1301.kt") + public void testKt1219_1301() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1219.1301.kt"); + } + + @Test + @TestMetadata("kt1571.kt") + public void testKt1571() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1571.kt"); + } + + @Test + @TestMetadata("kt1977.kt") + public void testKt1977() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1977.kt"); + } + + @Test + @TestMetadata("kt2166_kt2103.kt") + public void testKt2166_kt2103() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2166_kt2103.kt"); + } + + @Test + @TestMetadata("kt2226.kt") + public void testKt2226() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2226.kt"); + } + + @Test + @TestMetadata("kt2330.kt") + public void testKt2330() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2330.kt"); + } + + @Test + @TestMetadata("kt2334.kt") + public void testKt2334() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2334.kt"); + } + + @Test + @TestMetadata("kt2369.kt") + public void testKt2369() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2369.kt"); + } + + @Test + @TestMetadata("kt2845.kt") + public void testKt2845() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2845.kt"); + } + + @Test + @TestMetadata("kt2960.kt") + public void testKt2960() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2960.kt"); + } + + @Test + @TestMetadata("kt2972.kt") + public void testKt2972() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2972.kt"); + } + + @Test + @TestMetadata("kt3444.kt") + public void testKt3444() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt3444.kt"); + } + + @Test + @TestMetadata("kt3501.kt") + public void testKt3501() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt3501.kt"); + } + + @Test + @TestMetadata("kt4126.kt") + public void testKt4126() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt4126.kt"); + } + + @Test + @TestMetadata("kt4405.kt") + public void testKt4405() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt4405.kt"); + } + + @Test + @TestMetadata("kt510.kt") + public void testKt510() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt510.kt"); + } + + @Test + @TestMetadata("kt52131.kt") + public void testKt52131() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt52131.kt"); + } + + @Test + @TestMetadata("kt607.kt") + public void testKt607() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt607.kt"); + } + + @Test + @TestMetadata("kt609.kt") + public void testKt609() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt609.kt"); + } + + @Test + @TestMetadata("kt610.kt") + public void testKt610() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt610.kt"); + } + + @Test + @TestMetadata("kt6788.kt") + public void testKt6788() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt6788.kt"); + } + + @Test + @TestMetadata("kt776.kt") + public void testKt776() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt776.kt"); + } + + @Test + @TestMetadata("kt843.kt") + public void testKt843() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt843.kt"); + } + + @Test + @TestMetadata("kt897.kt") + public void testKt897() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt897.kt"); + } + + @Test + @TestMetadata("localClasses.kt") + public void testLocalClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/localClasses.kt"); + } + + @Test + @TestMetadata("localObjectInConstructor.kt") + public void testLocalObjectInConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/localObjectInConstructor.kt"); + } + + @Test + @TestMetadata("loopWithNonTrivialBooleanConst_error.kt") + public void testLoopWithNonTrivialBooleanConst_error() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/loopWithNonTrivialBooleanConst_error.kt"); + } + + @Test + @TestMetadata("loopWithNonTrivialBooleanConst_warning.kt") + public void testLoopWithNonTrivialBooleanConst_warning() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/loopWithNonTrivialBooleanConst_warning.kt"); + } + + @Test + @TestMetadata("mainWithWarningOnUnusedParam.kt") + public void testMainWithWarningOnUnusedParam() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/mainWithWarningOnUnusedParam.kt"); + } + + @Test + @TestMetadata("mainWithoutWarningOnUnusedParam.kt") + public void testMainWithoutWarningOnUnusedParam() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/mainWithoutWarningOnUnusedParam.kt"); + } + + @Test + @TestMetadata("nestedTryFinally.kt") + public void testNestedTryFinally() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/nestedTryFinally.kt"); + } + + @Test + @TestMetadata("nonLocalReturnUnreachable.kt") + public void testNonLocalReturnUnreachable() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/nonLocalReturnUnreachable.kt"); + } + + @Test + @TestMetadata("nonLocalReturnWithFinally.kt") + public void testNonLocalReturnWithFinally() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/nonLocalReturnWithFinally.kt"); + } + + @Test + @TestMetadata("privateSetter.kt") + public void testPrivateSetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/privateSetter.kt"); + } + + @Test + @TestMetadata("propertiesInitWithOtherInstance.kt") + public void testPropertiesInitWithOtherInstance() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstance.kt"); + } + + @Test + @TestMetadata("propertiesInitWithOtherInstanceInner.kt") + public void testPropertiesInitWithOtherInstanceInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstanceInner.kt"); + } + + @Test + @TestMetadata("propertiesInitWithOtherInstanceThisLabel.kt") + public void testPropertiesInitWithOtherInstanceThisLabel() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstanceThisLabel.kt"); + } + + @Test + @TestMetadata("propertiesOrderInPackage.kt") + public void testPropertiesOrderInPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesOrderInPackage.kt"); + } + + @Test + @TestMetadata("reassignmentInTryCatch.kt") + public void testReassignmentInTryCatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/reassignmentInTryCatch.kt"); + } + + @Test + @TestMetadata("reassignmentInTryCatchWithJumps.kt") + public void testReassignmentInTryCatchWithJumps() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/reassignmentInTryCatchWithJumps.kt"); + } + + @Test + @TestMetadata("referenceToPropertyInitializer.kt") + public void testReferenceToPropertyInitializer() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/referenceToPropertyInitializer.kt"); + } + + @Test + @TestMetadata("repeatUnitializedErrorOnlyForLocalVars.kt") + public void testRepeatUnitializedErrorOnlyForLocalVars() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/repeatUnitializedErrorOnlyForLocalVars.kt"); + } + + @Test + @TestMetadata("scopeOfAnonymousInitializer.kt") + public void testScopeOfAnonymousInitializer() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/scopeOfAnonymousInitializer.kt"); + } + + @Test + @TestMetadata("smartCastInCatch.kt") + public void testSmartCastInCatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/smartCastInCatch.kt"); + } + + @Test + @TestMetadata("throwInLambda.kt") + public void testThrowInLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/throwInLambda.kt"); + } + + @Test + @TestMetadata("tryWithAssignmentUsedInCatch.kt") + public void testTryWithAssignmentUsedInCatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/tryWithAssignmentUsedInCatch.kt"); + } + + @Test + @TestMetadata("uninintializedProperyWithDirectAndDelayedInitialization.kt") + public void testUninintializedProperyWithDirectAndDelayedInitialization() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/uninintializedProperyWithDirectAndDelayedInitialization.kt"); + } + + @Test + @TestMetadata("uninitializedCompanionOfEnum_after.kt") + public void testUninitializedCompanionOfEnum_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/uninitializedCompanionOfEnum_after.kt"); + } + + @Test + @TestMetadata("uninitializedCompanionOfEnum_before.kt") + public void testUninitializedCompanionOfEnum_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/uninitializedCompanionOfEnum_before.kt"); + } + + @Test + @TestMetadata("UninitializedEnumCompanionVals.kt") + public void testUninitializedEnumCompanionVals() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedEnumCompanionVals.kt"); + } + + @Test + @TestMetadata("uninitializedInLocalDeclarations.kt") + public void testUninitializedInLocalDeclarations() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/uninitializedInLocalDeclarations.kt"); + } + + @Test + @TestMetadata("UninitializedOrReassignedVariables.kt") + public void testUninitializedOrReassignedVariables() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedOrReassignedVariables.kt"); + } + + @Test + @TestMetadata("uninitializedQualifiedEnumEntry.kt") + public void testUninitializedQualifiedEnumEntry() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/uninitializedQualifiedEnumEntry.kt"); + } + + @Test + @TestMetadata("unmappedArgs.kt") + public void testUnmappedArgs() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unmappedArgs.kt"); + } + + @Test + @TestMetadata("unresolvedReference.kt") + public void testUnresolvedReference() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unresolvedReference.kt"); + } + + @Test + @TestMetadata("unusedPropertyWithCustomAccessors.kt") + public void testUnusedPropertyWithCustomAccessors() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unusedPropertyWithCustomAccessors.kt"); + } + + @Test + @TestMetadata("useUninitializedInLambda.kt") + public void testUseUninitializedInLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/useUninitializedInLambda.kt"); + } + + @Test + @TestMetadata("varInitializationInIfInCycle.kt") + public void testVarInitializationInIfInCycle() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/varInitializationInIfInCycle.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode") + @TestDataPath("$PROJECT_ROOT") + public class DeadCode { + @Test + public void testAllFilesPresentInDeadCode() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("commasAndWhitespaces.kt") + public void testCommasAndWhitespaces() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/commasAndWhitespaces.kt"); + } + + @Test + @TestMetadata("commentsInDeadCode.kt") + public void testCommentsInDeadCode() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/commentsInDeadCode.kt"); + } + + @Test + @TestMetadata("deadCallInInvokeCall.kt") + public void testDeadCallInInvokeCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCallInInvokeCall.kt"); + } + + @Test + @TestMetadata("deadCallInReceiver.kt") + public void testDeadCallInReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCallInReceiver.kt"); + } + + @Test + @TestMetadata("deadCodeDifferentExamples.kt") + public void testDeadCodeDifferentExamples() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeDifferentExamples.kt"); + } + + @Test + @TestMetadata("deadCodeFromDifferentSources.kt") + public void testDeadCodeFromDifferentSources() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeFromDifferentSources.kt"); + } + + @Test + @TestMetadata("deadCodeInArrayAccess.kt") + public void testDeadCodeInArrayAccess() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInArrayAccess.kt"); + } + + @Test + @TestMetadata("deadCodeInAssignment.kt") + public void testDeadCodeInAssignment() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInAssignment.kt"); + } + + @Test + @TestMetadata("deadCodeInBinaryExpressions.kt") + public void testDeadCodeInBinaryExpressions() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInBinaryExpressions.kt"); + } + + @Test + @TestMetadata("deadCodeInCalls.kt") + public void testDeadCodeInCalls() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInCalls.kt"); + } + + @Test + @TestMetadata("deadCodeInDeadCode.kt") + public void testDeadCodeInDeadCode() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInDeadCode.kt"); + } + + @Test + @TestMetadata("deadCodeInIf.kt") + public void testDeadCodeInIf() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInIf.kt"); + } + + @Test + @TestMetadata("deadCodeInInnerExpressions.kt") + public void testDeadCodeInInnerExpressions() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInInnerExpressions.kt"); + } + + @Test + @TestMetadata("deadCodeInLocalDeclarations.kt") + public void testDeadCodeInLocalDeclarations() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInLocalDeclarations.kt"); + } + + @Test + @TestMetadata("deadCodeInLoops.kt") + public void testDeadCodeInLoops() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInLoops.kt"); + } + + @Test + @TestMetadata("deadCodeInReturn.kt") + public void testDeadCodeInReturn() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInReturn.kt"); + } + + @Test + @TestMetadata("deadCodeInUnaryExpr.kt") + public void testDeadCodeInUnaryExpr() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInUnaryExpr.kt"); + } + + @Test + @TestMetadata("deadCodeInWhileFromBreak.kt") + public void testDeadCodeInWhileFromBreak() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInWhileFromBreak.kt"); + } + + @Test + @TestMetadata("expressionInUnitLiteral.kt") + public void testExpressionInUnitLiteral() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/expressionInUnitLiteral.kt"); + } + + @Test + @TestMetadata("kt2585_1.kt") + public void testKt2585_1() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/kt2585_1.kt"); + } + + @Test + @TestMetadata("kt2585_2.kt") + public void testKt2585_2() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/kt2585_2.kt"); + } + + @Test + @TestMetadata("kt2585_3.kt") + public void testKt2585_3() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/kt2585_3.kt"); + } + + @Test + @TestMetadata("kt3162tryAsInitializer.kt") + public void testKt3162tryAsInitializer() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/kt3162tryAsInitializer.kt"); + } + + @Test + @TestMetadata("kt5200DeadCodeInLambdas.kt") + public void testKt5200DeadCodeInLambdas() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/kt5200DeadCodeInLambdas.kt"); + } + + @Test + @TestMetadata("returnInDeadLambda.kt") + public void testReturnInDeadLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/returnInDeadLambda.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturn") + @TestDataPath("$PROJECT_ROOT") + public class DefiniteReturn { + @Test + public void testAllFilesPresentInDefiniteReturn() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturn"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("kt3444_ReturnFromLocalFunctions.kt") + public void testKt3444_ReturnFromLocalFunctions() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturn/kt3444_ReturnFromLocalFunctions.kt"); + } + + @Test + @TestMetadata("kt4034.kt") + public void testKt4034() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturn/kt4034.kt"); + } + + @Test + @TestMetadata("lambdaInTryFalsePositive.kt") + public void testLambdaInTryFalsePositive() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturn/lambdaInTryFalsePositive.kt"); + } + + @Test + @TestMetadata("ReturnFromFunctionInObject.kt") + public void testReturnFromFunctionInObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturn/ReturnFromFunctionInObject.kt"); + } + + @Test + @TestMetadata("simpleClass.kt") + public void testSimpleClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturn/simpleClass.kt"); + } + + @Test + @TestMetadata("singleReturnFromTry.kt") + public void testSingleReturnFromTry() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturn/singleReturnFromTry.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit") + @TestDataPath("$PROJECT_ROOT") + public class UnnecessaryLateinit { + @Test + public void testAllFilesPresentInUnnecessaryLateinit() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("lateinitRecursiveInLambda.kt") + public void testLateinitRecursiveInLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitRecursiveInLambda.kt"); + } + + @Test + @TestMetadata("lateinitWithConstructor.kt") + public void testLateinitWithConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithConstructor.kt"); + } + + @Test + @TestMetadata("lateinitWithErroneousDelegation.kt") + public void testLateinitWithErroneousDelegation() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithErroneousDelegation.kt"); + } + + @Test + @TestMetadata("lateinitWithInit.kt") + public void testLateinitWithInit() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithInit.kt"); + } + + @Test + @TestMetadata("lateinitWithMultipleConstructors.kt") + public void testLateinitWithMultipleConstructors() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithMultipleConstructors.kt"); + } + + @Test + @TestMetadata("lateinitWithMultipleConstructorsAndDelegation.kt") + public void testLateinitWithMultipleConstructorsAndDelegation() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithMultipleConstructorsAndDelegation.kt"); + } + + @Test + @TestMetadata("lateinitWithPlusAssign.kt") + public void testLateinitWithPlusAssign() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithPlusAssign.kt"); + } + + @Test + @TestMetadata("lateinitWithPrimaryConstructorAndConstructor.kt") + public void testLateinitWithPrimaryConstructorAndConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithPrimaryConstructorAndConstructor.kt"); + } + + @Test + @TestMetadata("normalLateinit.kt") + public void testNormalLateinit() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/normalLateinit.kt"); + } + + @Test + @TestMetadata("normalLateinitWithTwoConstructors.kt") + public void testNormalLateinitWithTwoConstructors() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/normalLateinitWithTwoConstructors.kt"); + } + + @Test + @TestMetadata("secondaryConstructorDelegateItself.kt") + public void testSecondaryConstructorDelegateItself() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/secondaryConstructorDelegateItself.kt"); + } + + @Test + @TestMetadata("secondaryConstructorDelegateLoop.kt") + public void testSecondaryConstructorDelegateLoop() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/secondaryConstructorDelegateLoop.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/controlStructures") + @TestDataPath("$PROJECT_ROOT") + public class ControlStructures { + @Test + public void testAllFilesPresentInControlStructures() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlStructures"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("breakContinueInCrossInlineLambda.kt") + public void testBreakContinueInCrossInlineLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/breakContinueInCrossInlineLambda.kt"); + } + + @Test + @TestMetadata("breakContinueInNoInlineLambda.kt") + public void testBreakContinueInNoInlineLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/breakContinueInNoInlineLambda.kt"); + } + + @Test + @TestMetadata("breakToLabel.kt") + public void testBreakToLabel() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/breakToLabel.kt"); + } + + @Test + @TestMetadata("catchGenerics.kt") + public void testCatchGenerics() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/catchGenerics.kt"); + } + + @Test + @TestMetadata("catchInnerClassesOfGenerics.kt") + public void testCatchInnerClassesOfGenerics() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/catchInnerClassesOfGenerics.kt"); + } + + @Test + @TestMetadata("catchInnerClassesOfGenerics_deprecation.kt") + public void testCatchInnerClassesOfGenerics_deprecation() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/catchInnerClassesOfGenerics_deprecation.kt"); + } + + @Test + @TestMetadata("catchWithDefault.kt") + public void testCatchWithDefault() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/catchWithDefault.kt"); + } + + @Test + @TestMetadata("catchingLocalClassesCapturingTypeParameters.kt") + public void testCatchingLocalClassesCapturingTypeParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/catchingLocalClassesCapturingTypeParameters.kt"); + } + + @Test + @TestMetadata("commonSupertypeOfT.kt") + public void testCommonSupertypeOfT() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/commonSupertypeOfT.kt"); + } + + @Test + @TestMetadata("continueAndBreakLabelWithSameFunctionName.kt") + public void testContinueAndBreakLabelWithSameFunctionName() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/continueAndBreakLabelWithSameFunctionName.kt"); + } + + @Test + @TestMetadata("emptyIf.kt") + public void testEmptyIf() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/emptyIf.kt"); + } + + @Test + @TestMetadata("ForLoopWithExtensionIteratorOnNullable.kt") + public void testForLoopWithExtensionIteratorOnNullable() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/ForLoopWithExtensionIteratorOnNullable.kt"); + } + + @Test + @TestMetadata("forLoopWithNullableRange.kt") + public void testForLoopWithNullableRange() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/forLoopWithNullableRange.kt"); + } + + @Test + @TestMetadata("forWithNullableIterator.kt") + public void testForWithNullableIterator() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/forWithNullableIterator.kt"); + } + + @Test + @TestMetadata("ForWithoutBraces.kt") + public void testForWithoutBraces() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/ForWithoutBraces.kt"); + } + + @Test + @TestMetadata("ForbidStatementAsDirectFunctionBody.kt") + public void testForbidStatementAsDirectFunctionBody() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/ForbidStatementAsDirectFunctionBody.kt"); + } + + @Test + @TestMetadata("ifElseIntersection.kt") + public void testIfElseIntersection() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/ifElseIntersection.kt"); + } + + @Test + @TestMetadata("ifInResultOfLambda.kt") + public void testIfInResultOfLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/ifInResultOfLambda.kt"); + } + + @Test + @TestMetadata("ifToAnyDiscriminatingUsages.kt") + public void testIfToAnyDiscriminatingUsages() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/ifToAnyDiscriminatingUsages.kt"); + } + + @Test + @TestMetadata("ifWhenToAnyComplexExpressions.kt") + public void testIfWhenToAnyComplexExpressions() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/ifWhenToAnyComplexExpressions.kt"); + } + + @Test + @TestMetadata("ifWhenWithoutElse.kt") + public void testIfWhenWithoutElse() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/ifWhenWithoutElse.kt"); + } + + @Test + @TestMetadata("improperElseInExpression.kt") + public void testImproperElseInExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/improperElseInExpression.kt"); + } + + @Test + @TestMetadata("incorrectElvis.kt") + public void testIncorrectElvis() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/incorrectElvis.kt"); + } + + @Test + @TestMetadata("jumpAcrossFunctionBoundary.kt") + public void testJumpAcrossFunctionBoundary() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/jumpAcrossFunctionBoundary.kt"); + } + + @Test + @TestMetadata("kt10322.kt") + public void testKt10322() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/kt10322.kt"); + } + + @Test + @TestMetadata("kt10706.kt") + public void testKt10706() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/kt10706.kt"); + } + + @Test + @TestMetadata("kt10717.kt") + public void testKt10717() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/kt10717.kt"); + } + + @Test + @TestMetadata("kt1075.kt") + public void testKt1075() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/kt1075.kt"); + } + + @Test + @TestMetadata("kt30406.kt") + public void testKt30406() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/kt30406.kt"); + } + + @Test + @TestMetadata("kt4310.kt") + public void testKt4310() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/kt4310.kt"); + } + + @Test + @TestMetadata("kt51711.kt") + public void testKt51711() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/kt51711.kt"); + } + + @Test + @TestMetadata("kt657.kt") + public void testKt657() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/kt657.kt"); + } + + @Test + @TestMetadata("kt770.kt351.kt735_StatementType.kt") + public void testKt770_kt351_kt735_StatementType() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt"); + } + + @Test + @TestMetadata("kt786.kt") + public void testKt786() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/kt786.kt"); + } + + @Test + @TestMetadata("kt799.kt") + public void testKt799() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/kt799.kt"); + } + + @Test + @TestMetadata("lambdasInExclExclAndElvis.kt") + public void testLambdasInExclExclAndElvis() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/lambdasInExclExclAndElvis.kt"); + } + + @Test + @TestMetadata("localReturnInsidePropertyAccessor.kt") + public void testLocalReturnInsidePropertyAccessor() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/localReturnInsidePropertyAccessor.kt"); + } + + @Test + @TestMetadata("nestedLoopsWithMultipleLabels.kt") + public void testNestedLoopsWithMultipleLabels() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/nestedLoopsWithMultipleLabels.kt"); + } + + @Test + @TestMetadata("nonExhaustiveIfInElvis_after.kt") + public void testNonExhaustiveIfInElvis_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/nonExhaustiveIfInElvis_after.kt"); + } + + @Test + @TestMetadata("nonExhaustiveIfInElvis_before.kt") + public void testNonExhaustiveIfInElvis_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/nonExhaustiveIfInElvis_before.kt"); + } + + @Test + @TestMetadata("notAFunctionLabel_after.kt") + public void testNotAFunctionLabel_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/notAFunctionLabel_after.kt"); + } + + @Test + @TestMetadata("notAFunctionLabel_before.kt") + public void testNotAFunctionLabel_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/notAFunctionLabel_before.kt"); + } + + @Test + @TestMetadata("redundantLabel.kt") + public void testRedundantLabel() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/redundantLabel.kt"); + } + + @Test + @TestMetadata("specialConstructsAndPlatformTypes.kt") + public void testSpecialConstructsAndPlatformTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/specialConstructsAndPlatformTypes.kt"); + } + + @Test + @TestMetadata("specialConstructsWithNullableExpectedType.kt") + public void testSpecialConstructsWithNullableExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/specialConstructsWithNullableExpectedType.kt"); + } + + @Test + @TestMetadata("tryReturnType.kt") + public void testTryReturnType() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/tryReturnType.kt"); + } + + @Test + @TestMetadata("typeInferenceForExclExcl.kt") + public void testTypeInferenceForExclExcl() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/typeInferenceForExclExcl.kt"); + } + + @Test + @TestMetadata("valVarCatchParameter.kt") + public void testValVarCatchParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/valVarCatchParameter.kt"); + } + + @Test + @TestMetadata("valVarLoopParameter.kt") + public void testValVarLoopParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/valVarLoopParameter.kt"); + } + + @Test + @TestMetadata("whenInResultOfLambda.kt") + public void testWhenInResultOfLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/whenInResultOfLambda.kt"); + } + + @Test + @TestMetadata("whenToAnyDiscriminatingUsages.kt") + public void testWhenToAnyDiscriminatingUsages() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/whenToAnyDiscriminatingUsages.kt"); + } + + @Test + @TestMetadata("whenWithNothingTypedSubject.kt") + public void testWhenWithNothingTypedSubject() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/whenWithNothingTypedSubject.kt"); + } + + @Test + @TestMetadata("when.kt234.kt973.kt") + public void testWhen_kt234_kt973() throws Exception { + runTest("compiler/testData/diagnostics/tests/controlStructures/when.kt234.kt973.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/coroutines") + @TestDataPath("$PROJECT_ROOT") + public class Coroutines { + @Test + public void testAllFilesPresentInCoroutines() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/coroutines"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("inlineSuspendTypealias.kt") + public void testInlineSuspendTypealias() throws Exception { + runTest("compiler/testData/diagnostics/tests/coroutines/inlineSuspendTypealias.kt"); + } + + @Test + @TestMetadata("modifierFormBuiltinSuspendFun.kt") + public void testModifierFormBuiltinSuspendFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/coroutines/modifierFormBuiltinSuspendFun.kt"); + } + + @Test + @TestMetadata("suspendInvokeInsideTry.kt") + public void testSuspendInvokeInsideTry() throws Exception { + runTest("compiler/testData/diagnostics/tests/coroutines/suspendInvokeInsideTry.kt"); + } + + @Test + @TestMetadata("suspendInvokeInsideWhen.kt") + public void testSuspendInvokeInsideWhen() throws Exception { + runTest("compiler/testData/diagnostics/tests/coroutines/suspendInvokeInsideWhen.kt"); + } + + @Test + @TestMetadata("suspendInvokeWithReceiver.kt") + public void testSuspendInvokeWithReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/coroutines/suspendInvokeWithReceiver.kt"); + } + + @Test + @TestMetadata("suspendLambdaFromExpectedType.kt") + public void testSuspendLambdaFromExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/coroutines/suspendLambdaFromExpectedType.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/coroutines/callableReference") + @TestDataPath("$PROJECT_ROOT") + public class CallableReference { + @Test + public void testAllFilesPresentInCallableReference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/coroutines/callableReference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("invokeOutideSuspend.kt") + public void testInvokeOutideSuspend() throws Exception { + runTest("compiler/testData/diagnostics/tests/coroutines/callableReference/invokeOutideSuspend.kt"); + } + + @Test + @TestMetadata("outsideSuspend.kt") + public void testOutsideSuspend() throws Exception { + runTest("compiler/testData/diagnostics/tests/coroutines/callableReference/outsideSuspend.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/coroutines/suspendFunctionAsSupertype") + @TestDataPath("$PROJECT_ROOT") + public class SuspendFunctionAsSupertype { + @Test + public void testAllFilesPresentInSuspendFunctionAsSupertype() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/coroutines/suspendFunctionAsSupertype"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/coroutines/suspendFunctionAsSupertype/kSuspendFunctionN") + @TestDataPath("$PROJECT_ROOT") + public class KSuspendFunctionN { + @Test + public void testAllFilesPresentInKSuspendFunctionN() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/coroutines/suspendFunctionAsSupertype/kSuspendFunctionN"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("mixingSuspendAndNonSuspendSupertypes.kt") + public void testMixingSuspendAndNonSuspendSupertypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/coroutines/suspendFunctionAsSupertype/kSuspendFunctionN/mixingSuspendAndNonSuspendSupertypes.kt"); + } + + @Test + @TestMetadata("mixingSuspendAndNonSuspendSupertypesThruSuperClass.kt") + public void testMixingSuspendAndNonSuspendSupertypesThruSuperClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/coroutines/suspendFunctionAsSupertype/kSuspendFunctionN/mixingSuspendAndNonSuspendSupertypesThruSuperClass.kt"); + } + + @Test + @TestMetadata("mixingSuspendAndNonSuspendSupertypesThruSuperFunInterface.kt") + public void testMixingSuspendAndNonSuspendSupertypesThruSuperFunInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/coroutines/suspendFunctionAsSupertype/kSuspendFunctionN/mixingSuspendAndNonSuspendSupertypesThruSuperFunInterface.kt"); + } + + @Test + @TestMetadata("mixingSuspendAndNonSuspendSupertypesThruSuperinterface.kt") + public void testMixingSuspendAndNonSuspendSupertypesThruSuperinterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/coroutines/suspendFunctionAsSupertype/kSuspendFunctionN/mixingSuspendAndNonSuspendSupertypesThruSuperinterface.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/coroutines/suspendFunctionAsSupertype/kSuspendFunctionN/simple.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/coroutines/suspendFunctionAsSupertype/simple") + @TestDataPath("$PROJECT_ROOT") + public class Simple { + @Test + public void testAllFilesPresentInSimple() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/coroutines/suspendFunctionAsSupertype/simple"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("mixingSuspendAndNonSuspendSupertypes.kt") + public void testMixingSuspendAndNonSuspendSupertypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/coroutines/suspendFunctionAsSupertype/simple/mixingSuspendAndNonSuspendSupertypes.kt"); + } + + @Test + @TestMetadata("mixingSuspendAndNonSuspendSupertypesThruSuperClass.kt") + public void testMixingSuspendAndNonSuspendSupertypesThruSuperClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/coroutines/suspendFunctionAsSupertype/simple/mixingSuspendAndNonSuspendSupertypesThruSuperClass.kt"); + } + + @Test + @TestMetadata("mixingSuspendAndNonSuspendSupertypesThruSuperFunInterface.kt") + public void testMixingSuspendAndNonSuspendSupertypesThruSuperFunInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/coroutines/suspendFunctionAsSupertype/simple/mixingSuspendAndNonSuspendSupertypesThruSuperFunInterface.kt"); + } + + @Test + @TestMetadata("mixingSuspendAndNonSuspendSupertypesThruSuperinterface.kt") + public void testMixingSuspendAndNonSuspendSupertypesThruSuperinterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/coroutines/suspendFunctionAsSupertype/simple/mixingSuspendAndNonSuspendSupertypesThruSuperinterface.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/coroutines/suspendFunctionAsSupertype/simple/simple.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/coroutines/suspendFunctionAsSupertype/suspendFunctionN") + @TestDataPath("$PROJECT_ROOT") + public class SuspendFunctionN { + @Test + public void testAllFilesPresentInSuspendFunctionN() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/coroutines/suspendFunctionAsSupertype/suspendFunctionN"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("mixingSuspendAndNonSuspendSupertypes.kt") + public void testMixingSuspendAndNonSuspendSupertypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/coroutines/suspendFunctionAsSupertype/suspendFunctionN/mixingSuspendAndNonSuspendSupertypes.kt"); + } + + @Test + @TestMetadata("mixingSuspendAndNonSuspendSupertypesThruSuperClass.kt") + public void testMixingSuspendAndNonSuspendSupertypesThruSuperClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/coroutines/suspendFunctionAsSupertype/suspendFunctionN/mixingSuspendAndNonSuspendSupertypesThruSuperClass.kt"); + } + + @Test + @TestMetadata("mixingSuspendAndNonSuspendSupertypesThruSuperFunInterface.kt") + public void testMixingSuspendAndNonSuspendSupertypesThruSuperFunInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/coroutines/suspendFunctionAsSupertype/suspendFunctionN/mixingSuspendAndNonSuspendSupertypesThruSuperFunInterface.kt"); + } + + @Test + @TestMetadata("mixingSuspendAndNonSuspendSupertypesThruSuperinterface.kt") + public void testMixingSuspendAndNonSuspendSupertypesThruSuperinterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/coroutines/suspendFunctionAsSupertype/suspendFunctionN/mixingSuspendAndNonSuspendSupertypesThruSuperinterface.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/coroutines/suspendFunctionAsSupertype/suspendFunctionN/simple.kt"); + } + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/cyclicHierarchy") + @TestDataPath("$PROJECT_ROOT") + public class CyclicHierarchy { + @Test + public void testAllFilesPresentInCyclicHierarchy() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cyclicHierarchy"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("classIndirectlyInheritsNested.kt") + public void testClassIndirectlyInheritsNested() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/classIndirectlyInheritsNested.kt"); + } + + @Test + @TestMetadata("classInheritsNested.kt") + public void testClassInheritsNested() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/classInheritsNested.kt"); + } + + @Test + @TestMetadata("commonSupertypeForCyclicAndUsualTypes.kt") + public void testCommonSupertypeForCyclicAndUsualTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/commonSupertypeForCyclicAndUsualTypes.kt"); + } + + @Test + @TestMetadata("commonSupertypeForCyclicTypes.kt") + public void testCommonSupertypeForCyclicTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/commonSupertypeForCyclicTypes.kt"); + } + + @Test + @TestMetadata("cyclicHierarchy.kt") + public void testCyclicHierarchy() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/cyclicHierarchy.kt"); + } + + @Test + @TestMetadata("javaJavaCycle.kt") + public void testJavaJavaCycle() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/javaJavaCycle.kt"); + } + + @Test + @TestMetadata("javaJavaNested.kt") + public void testJavaJavaNested() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/javaJavaNested.kt"); + } + + @Test + @TestMetadata("javaKotlinJavaCycle.kt") + public void testJavaKotlinJavaCycle() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/javaKotlinJavaCycle.kt"); + } + + @Test + @TestMetadata("kotlinJavaCycle.kt") + public void testKotlinJavaCycle() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaCycle.kt"); + } + + @Test + @TestMetadata("kotlinJavaKotlinCycle.kt") + public void testKotlinJavaKotlinCycle() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaKotlinCycle.kt"); + } + + @Test + @TestMetadata("kotlinJavaNestedCycle.kt") + public void testKotlinJavaNestedCycle() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaNestedCycle.kt"); + } + + @Test + @TestMetadata("kt303.kt") + public void testKt303() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/kt303.kt"); + } + + @Test + @TestMetadata("nestedClassInSuperClassParameter.kt") + public void testNestedClassInSuperClassParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/nestedClassInSuperClassParameter.kt"); + } + + @Test + @TestMetadata("objectInheritsNested.kt") + public void testObjectInheritsNested() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/objectInheritsNested.kt"); + } + + @Test + @TestMetadata("twoClassesWithNestedCycle.kt") + public void testTwoClassesWithNestedCycle() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/twoClassesWithNestedCycle.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion") + @TestDataPath("$PROJECT_ROOT") + public class WithCompanion { + @Test + public void testAllFilesPresentInWithCompanion() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("everythingInOneScope_after.kt") + public void testEverythingInOneScope_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/everythingInOneScope_after.kt"); + } + + @Test + @TestMetadata("everythingInOneScope_before.kt") + public void testEverythingInOneScope_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/everythingInOneScope_before.kt"); + } + + @Test + @TestMetadata("noMembers_after.kt") + public void testNoMembers_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/noMembers_after.kt"); + } + + @Test + @TestMetadata("noMembers_before.kt") + public void testNoMembers_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/noMembers_before.kt"); + } + + @Test + @TestMetadata("onlyInterfaces_after.kt") + public void testOnlyInterfaces_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/onlyInterfaces_after.kt"); + } + + @Test + @TestMetadata("onlyInterfaces_before.kt") + public void testOnlyInterfaces_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/onlyInterfaces_before.kt"); + } + + @Test + @TestMetadata("typeIsLowEnough.kt") + public void testTypeIsLowEnough() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/typeIsLowEnough.kt"); + } + + @Test + @TestMetadata("withIrrelevantInterface_after.kt") + public void testWithIrrelevantInterface_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/withIrrelevantInterface_after.kt"); + } + + @Test + @TestMetadata("withIrrelevantInterface_before.kt") + public void testWithIrrelevantInterface_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/withIrrelevantInterface_before.kt"); + } + + @Test + @TestMetadata("withMembers_after.kt") + public void testWithMembers_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/withMembers_after.kt"); + } + + @Test + @TestMetadata("withMembers_before.kt") + public void testWithMembers_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/withMembers_before.kt"); + } + + @Test + @TestMetadata("withoutTypeReference.kt") + public void testWithoutTypeReference() throws Exception { + runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/withoutTypeReference.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/dataClasses") + @TestDataPath("$PROJECT_ROOT") + public class DataClasses { + @Test + public void testAllFilesPresentInDataClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataClasses"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("companionDataObject.kt") + public void testCompanionDataObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/companionDataObject.kt"); + } + + @Test + @TestMetadata("componentNamedComponent1.kt") + public void testComponentNamedComponent1() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/componentNamedComponent1.kt"); + } + + @Test + @TestMetadata("conflictingCopyOverloads.kt") + public void testConflictingCopyOverloads() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/conflictingCopyOverloads.kt"); + } + + @Test + @TestMetadata("conflictingOverloads.kt") + public void testConflictingOverloads() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/conflictingOverloads.kt"); + } + + @Test + @TestMetadata("copyOfPrivateClass.kt") + public void testCopyOfPrivateClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/copyOfPrivateClass.kt"); + } + + @Test + @TestMetadata("dataClassExplicitlyOverridingCopyNoDefaults.kt") + public void testDataClassExplicitlyOverridingCopyNoDefaults() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/dataClassExplicitlyOverridingCopyNoDefaults.kt"); + } + + @Test + @TestMetadata("dataClassExplicitlyOverridingCopyWithDefaults.kt") + public void testDataClassExplicitlyOverridingCopyWithDefaults() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/dataClassExplicitlyOverridingCopyWithDefaults.kt"); + } + + @Test + @TestMetadata("dataClassNoName.kt") + public void testDataClassNoName() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/dataClassNoName.kt"); + } + + @Test + @TestMetadata("dataClassNotOverridingCopy.kt") + public void testDataClassNotOverridingCopy() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/dataClassNotOverridingCopy.kt"); + } + + @Test + @TestMetadata("dataClassOverridingCopy_lv12.kt") + public void testDataClassOverridingCopy_lv12() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/dataClassOverridingCopy_lv12.kt"); + } + + @Test + @TestMetadata("dataClassOverridingCopy_lv13.kt") + public void testDataClassOverridingCopy_lv13() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/dataClassOverridingCopy_lv13.kt"); + } + + @Test + @TestMetadata("dataClassVarargParam.kt") + public void testDataClassVarargParam() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/dataClassVarargParam.kt"); + } + + @Test + @TestMetadata("dataInheritance.kt") + public void testDataInheritance() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/dataInheritance.kt"); + } + + @Test + @TestMetadata("dataObjectDisabled.kt") + public void testDataObjectDisabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/dataObjectDisabled.kt"); + } + + @Test + @TestMetadata("dataObjectEnabled.kt") + public void testDataObjectEnabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/dataObjectEnabled.kt"); + } + + @Test + @TestMetadata("dataObjectLiteral.kt") + public void testDataObjectLiteral() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/dataObjectLiteral.kt"); + } + + @Test + @TestMetadata("emptyConstructor.kt") + public void testEmptyConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/emptyConstructor.kt"); + } + + @Test + @TestMetadata("errorTypesInDataClasses.kt") + public void testErrorTypesInDataClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/errorTypesInDataClasses.kt"); + } + + @Test + @TestMetadata("extensionComponentsOnNullable.kt") + public void testExtensionComponentsOnNullable() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/extensionComponentsOnNullable.kt"); + } + + @Test + @TestMetadata("finalMembersInBaseClass.kt") + public void testFinalMembersInBaseClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/finalMembersInBaseClass.kt"); + } + + @Test + @TestMetadata("implementMethodsFromInterface.kt") + public void testImplementMethodsFromInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/implementMethodsFromInterface.kt"); + } + + @Test + @TestMetadata("implementTraitWhichHasComponent1.kt") + public void testImplementTraitWhichHasComponent1() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/implementTraitWhichHasComponent1.kt"); + } + + @Test + @TestMetadata("implementTraitWhichHasFinalComponent1.kt") + public void testImplementTraitWhichHasFinalComponent1() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/implementTraitWhichHasFinalComponent1.kt"); + } + + @Test + @TestMetadata("innerDataClass.kt") + public void testInnerDataClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/innerDataClass.kt"); + } + + @Test + @TestMetadata("innerOuterDataClass.kt") + public void testInnerOuterDataClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/innerOuterDataClass.kt"); + } + + @Test + @TestMetadata("multiDeclaration.kt") + public void testMultiDeclaration() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/multiDeclaration.kt"); + } + + @Test + @TestMetadata("multiDeclarationFor.kt") + public void testMultiDeclarationFor() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/multiDeclarationFor.kt"); + } + + @Test + @TestMetadata("noConstructor.kt") + public void testNoConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/noConstructor.kt"); + } + + @Test + @TestMetadata("notADataClass.kt") + public void testNotADataClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/notADataClass.kt"); + } + + @Test + @TestMetadata("oneValParam.kt") + public void testOneValParam() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/oneValParam.kt"); + } + + @Test + @TestMetadata("repeatedProperties.kt") + public void testRepeatedProperties() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/repeatedProperties.kt"); + } + + @Test + @TestMetadata("sealedDataClass.kt") + public void testSealedDataClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/sealedDataClass.kt"); + } + + @Test + @TestMetadata("strange.kt") + public void testStrange() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/strange.kt"); + } + + @Test + @TestMetadata("twoValParams.kt") + public void testTwoValParams() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/twoValParams.kt"); + } + + @Test + @TestMetadata("twoVarParams.kt") + public void testTwoVarParams() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataClasses/twoVarParams.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/dataFlow") + @TestDataPath("$PROJECT_ROOT") + public class DataFlow { + @Test + public void testAllFilesPresentInDataFlow() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlow"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("CalleeExpression.kt") + public void testCalleeExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlow/CalleeExpression.kt"); + } + + @Test + @TestMetadata("EmptyIf.kt") + public void testEmptyIf() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlow/EmptyIf.kt"); + } + + @Test + @TestMetadata("IsExpression.kt") + public void testIsExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlow/IsExpression.kt"); + } + + @Test + @TestMetadata("smartCastWithLambdaAndCallableReference.kt") + public void testSmartCastWithLambdaAndCallableReference() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlow/smartCastWithLambdaAndCallableReference.kt"); + } + + @Test + @TestMetadata("WhenSubject.kt") + public void testWhenSubject() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlow/WhenSubject.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/dataFlow/assignment") + @TestDataPath("$PROJECT_ROOT") + public class Assignment { + @Test + public void testAllFilesPresentInAssignment() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlow/assignment"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("assignToNewVal.kt") + public void testAssignToNewVal() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlow/assignment/assignToNewVal.kt"); + } + + @Test + @TestMetadata("kt6118.kt") + public void testKt6118() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlow/assignment/kt6118.kt"); + } + + @Test + @TestMetadata("uninitializedValIsCheck.kt") + public void testUninitializedValIsCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlow/assignment/uninitializedValIsCheck.kt"); + } + + @Test + @TestMetadata("uninitializedValNullability.kt") + public void testUninitializedValNullability() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlow/assignment/uninitializedValNullability.kt"); + } + + @Test + @TestMetadata("when.kt") + public void testWhen() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlow/assignment/when.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/dataFlow/local") + @TestDataPath("$PROJECT_ROOT") + public class Local { + @Test + public void testAllFilesPresentInLocal() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlow/local"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("kt2835.kt") + public void testKt2835() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlow/local/kt2835.kt"); + } + + @Test + @TestMetadata("LocalClassBase.kt") + public void testLocalClassBase() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlow/local/LocalClassBase.kt"); + } + + @Test + @TestMetadata("LocalClassDefaultParameters.kt") + public void testLocalClassDefaultParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlow/local/LocalClassDefaultParameters.kt"); + } + + @Test + @TestMetadata("LocalClassDelegatedProperties.kt") + public void testLocalClassDelegatedProperties() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlow/local/LocalClassDelegatedProperties.kt"); + } + + @Test + @TestMetadata("LocalClassDelegation.kt") + public void testLocalClassDelegation() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlow/local/LocalClassDelegation.kt"); + } + + @Test + @TestMetadata("LocalClassFunctions.kt") + public void testLocalClassFunctions() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlow/local/LocalClassFunctions.kt"); + } + + @Test + @TestMetadata("LocalClassInMemberOfLocalClass.kt") + public void testLocalClassInMemberOfLocalClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlow/local/LocalClassInMemberOfLocalClass.kt"); + } + + @Test + @TestMetadata("LocalClassInitializer.kt") + public void testLocalClassInitializer() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlow/local/LocalClassInitializer.kt"); + } + + @Test + @TestMetadata("LocalClassProperty.kt") + public void testLocalClassProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlow/local/LocalClassProperty.kt"); + } + + @Test + @TestMetadata("LocalObject.kt") + public void testLocalObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlow/local/LocalObject.kt"); + } + + @Test + @TestMetadata("LocalObjectDelegation.kt") + public void testLocalObjectDelegation() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlow/local/LocalObjectDelegation.kt"); + } + + @Test + @TestMetadata("NestedLocalClass.kt") + public void testNestedLocalClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlow/local/NestedLocalClass.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal") + @TestDataPath("$PROJECT_ROOT") + public class DataFlowInfoTraversal { + @Test + public void testAllFilesPresentInDataFlowInfoTraversal() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlowInfoTraversal"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("AndOr.kt") + public void testAndOr() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/AndOr.kt"); + } + + @Test + @TestMetadata("ArrayAccess.kt") + public void testArrayAccess() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayAccess.kt"); + } + + @Test + @TestMetadata("ArrayExpression.kt") + public void testArrayExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayExpression.kt"); + } + + @Test + @TestMetadata("ArrayGetSetConvention.kt") + public void testArrayGetSetConvention() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayGetSetConvention.kt"); + } + + @Test + @TestMetadata("ArrayIndices.kt") + public void testArrayIndices() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayIndices.kt"); + } + + @Test + @TestMetadata("Assignment.kt") + public void testAssignment() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Assignment.kt"); + } + + @Test + @TestMetadata("AssignmentInInitializer.kt") + public void testAssignmentInInitializer() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/AssignmentInInitializer.kt"); + } + + @Test + @TestMetadata("AssignmentOperation.kt") + public void testAssignmentOperation() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/AssignmentOperation.kt"); + } + + @Test + @TestMetadata("AssignmentToArrayElement.kt") + public void testAssignmentToArrayElement() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/AssignmentToArrayElement.kt"); + } + + @Test + @TestMetadata("BinaryExpression.kt") + public void testBinaryExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpression.kt"); + } + + @Test + @TestMetadata("BinaryExpressionBooleanOperations.kt") + public void testBinaryExpressionBooleanOperations() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionBooleanOperations.kt"); + } + + @Test + @TestMetadata("BinaryExpressionCompareToConvention.kt") + public void testBinaryExpressionCompareToConvention() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionCompareToConvention.kt"); + } + + @Test + @TestMetadata("BinaryExpressionContainsConvention.kt") + public void testBinaryExpressionContainsConvention() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionContainsConvention.kt"); + } + + @Test + @TestMetadata("BinaryExpressionElvis.kt") + public void testBinaryExpressionElvis() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionElvis.kt"); + } + + @Test + @TestMetadata("BinaryExpressionEqualsConvention.kt") + public void testBinaryExpressionEqualsConvention() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionEqualsConvention.kt"); + } + + @Test + @TestMetadata("BinaryExpressionIdentifier.kt") + public void testBinaryExpressionIdentifier() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionIdentifier.kt"); + } + + @Test + @TestMetadata("BinaryExpressionPlusConvention.kt") + public void testBinaryExpressionPlusConvention() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionPlusConvention.kt"); + } + + @Test + @TestMetadata("Condition.kt") + public void testCondition() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Condition.kt"); + } + + @Test + @TestMetadata("ContinueOuterLoop.kt") + public void testContinueOuterLoop() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ContinueOuterLoop.kt"); + } + + @Test + @TestMetadata("DeepIf.kt") + public void testDeepIf() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DeepIf.kt"); + } + + @Test + @TestMetadata("DoWhile.kt") + public void testDoWhile() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DoWhile.kt"); + } + + @Test + @TestMetadata("DoWhileCondition.kt") + public void testDoWhileCondition() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DoWhileCondition.kt"); + } + + @Test + @TestMetadata("Elvis.kt") + public void testElvis() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Elvis.kt"); + } + + @Test + @TestMetadata("ExclExcl.kt") + public void testExclExcl() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ExclExcl.kt"); + } + + @Test + @TestMetadata("For.kt") + public void testFor() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/For.kt"); + } + + @Test + @TestMetadata("ForLoopRange.kt") + public void testForLoopRange() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ForLoopRange.kt"); + } + + @Test + @TestMetadata("FunctionLiteral.kt") + public void testFunctionLiteral() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/FunctionLiteral.kt"); + } + + @Test + @TestMetadata("IfStatement.kt") + public void testIfStatement() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfStatement.kt"); + } + + @Test + @TestMetadata("IfThenElse.kt") + public void testIfThenElse() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfThenElse.kt"); + } + + @Test + @TestMetadata("IfThenElseBothInvalid.kt") + public void testIfThenElseBothInvalid() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfThenElseBothInvalid.kt"); + } + + @Test + @TestMetadata("IsExpression.kt") + public void testIsExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IsExpression.kt"); + } + + @Test + @TestMetadata("kt4332WhenBranches.kt") + public void testKt4332WhenBranches() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/kt4332WhenBranches.kt"); + } + + @Test + @TestMetadata("kt5155WhenBranches.kt") + public void testKt5155WhenBranches() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/kt5155WhenBranches.kt"); + } + + @Test + @TestMetadata("kt5182WhenBranches.kt") + public void testKt5182WhenBranches() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/kt5182WhenBranches.kt"); + } + + @Test + @TestMetadata("ManyIfs.kt") + public void testManyIfs() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ManyIfs.kt"); + } + + @Test + @TestMetadata("MultiDeclaration.kt") + public void testMultiDeclaration() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/MultiDeclaration.kt"); + } + + @Test + @TestMetadata("ObjectExpression.kt") + public void testObjectExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ObjectExpression.kt"); + } + + @Test + @TestMetadata("QualifiedExpression.kt") + public void testQualifiedExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/QualifiedExpression.kt"); + } + + @Test + @TestMetadata("Return.kt") + public void testReturn() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Return.kt"); + } + + @Test + @TestMetadata("StringTemplate.kt") + public void testStringTemplate() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/StringTemplate.kt"); + } + + @Test + @TestMetadata("ThisSuper.kt") + public void testThisSuper() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ThisSuper.kt"); + } + + @Test + @TestMetadata("Throw.kt") + public void testThrow() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Throw.kt"); + } + + @Test + @TestMetadata("TryCatch.kt") + public void testTryCatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/TryCatch.kt"); + } + + @Test + @TestMetadata("TryFinally.kt") + public void testTryFinally() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/TryFinally.kt"); + } + + @Test + @TestMetadata("UnaryExpression.kt") + public void testUnaryExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/UnaryExpression.kt"); + } + + @Test + @TestMetadata("When.kt") + public void testWhen() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/When.kt"); + } + + @Test + @TestMetadata("WhenEntryAs.kt") + public void testWhenEntryAs() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/WhenEntryAs.kt"); + } + + @Test + @TestMetadata("WhenEntryIs.kt") + public void testWhenEntryIs() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/WhenEntryIs.kt"); + } + + @Test + @TestMetadata("WhenIn.kt") + public void testWhenIn() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/WhenIn.kt"); + } + + @Test + @TestMetadata("WhenSubject.kt") + public void testWhenSubject() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/WhenSubject.kt"); + } + + @Test + @TestMetadata("While.kt") + public void testWhile() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/While.kt"); + } + + @Test + @TestMetadata("WhileCondition.kt") + public void testWhileCondition() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/WhileCondition.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/smartcasts") + @TestDataPath("$PROJECT_ROOT") + public class Smartcasts { + @Test + public void testAllFilesPresentInSmartcasts() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/smartcasts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("SmartcastAmbiguitites.kt") + public void testSmartcastAmbiguitites() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/smartcasts/SmartcastAmbiguitites.kt"); + } + + @Test + @TestMetadata("SmartcastsForStableIdentifiers.kt") + public void testSmartcastsForStableIdentifiers() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/smartcasts/SmartcastsForStableIdentifiers.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/dataObjects") + @TestDataPath("$PROJECT_ROOT") + public class DataObjects { + @Test + public void testAllFilesPresentInDataObjects() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataObjects"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("overrideEqualsAndHashCode.kt") + public void testOverrideEqualsAndHashCode() throws Exception { + runTest("compiler/testData/diagnostics/tests/dataObjects/overrideEqualsAndHashCode.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/declarationChecks") + @TestDataPath("$PROJECT_ROOT") + public class DeclarationChecks { + @Test + public void testAllFilesPresentInDeclarationChecks() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("ambiguousObjectExpressionType.kt") + public void testAmbiguousObjectExpressionType() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.kt"); + } + + @Test + @TestMetadata("anonymousFunAsLastExpressionInBlock.kt") + public void testAnonymousFunAsLastExpressionInBlock() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/anonymousFunAsLastExpressionInBlock.kt"); + } + + @Test + @TestMetadata("anonymousFunUnusedLastExpressionInBlock.kt") + public void testAnonymousFunUnusedLastExpressionInBlock() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/anonymousFunUnusedLastExpressionInBlock.kt"); + } + + @Test + @TestMetadata("ComponentFunctionReturnTypeMismatch.kt") + public void testComponentFunctionReturnTypeMismatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/ComponentFunctionReturnTypeMismatch.kt"); + } + + @Test + @TestMetadata("ConflictingAndRedundantProjections.kt") + public void testConflictingAndRedundantProjections() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/ConflictingAndRedundantProjections.kt"); + } + + @Test + @TestMetadata("DataFlowInMultiDeclInFor.kt") + public void testDataFlowInMultiDeclInFor() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/DataFlowInMultiDeclInFor.kt"); + } + + @Test + @TestMetadata("DataFlowInfoInMultiDecl.kt") + public void testDataFlowInfoInMultiDecl() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/DataFlowInfoInMultiDecl.kt"); + } + + @Test + @TestMetadata("FunctionWithMissingNames.kt") + public void testFunctionWithMissingNames() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/FunctionWithMissingNames.kt"); + } + + @Test + @TestMetadata("illegalModifiersOnClass.kt") + public void testIllegalModifiersOnClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.kt"); + } + + @Test + @TestMetadata("kClassInSignature.kt") + public void testKClassInSignature() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/kClassInSignature.kt"); + } + + @Test + @TestMetadata("kt1141.kt") + public void testKt1141() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/kt1141.kt"); + } + + @Test + @TestMetadata("kt1193.kt") + public void testKt1193() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/kt1193.kt"); + } + + @Test + @TestMetadata("kt2096.kt") + public void testKt2096() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/kt2096.kt"); + } + + @Test + @TestMetadata("kt2142.kt") + public void testKt2142() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/kt2142.kt"); + } + + @Test + @TestMetadata("kt2397.kt") + public void testKt2397() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/kt2397.kt"); + } + + @Test + @TestMetadata("kt2631_MultipleDeclaration.kt") + public void testKt2631_MultipleDeclaration() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/kt2631_MultipleDeclaration.kt"); + } + + @Test + @TestMetadata("kt2643MultiDeclInControlFlow.kt") + public void testKt2643MultiDeclInControlFlow() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/kt2643MultiDeclInControlFlow.kt"); + } + + @Test + @TestMetadata("kt559.kt") + public void testKt559() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/kt559.kt"); + } + + @Test + @TestMetadata("localDeclarationModifiers.kt") + public void testLocalDeclarationModifiers() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/localDeclarationModifiers.kt"); + } + + @Test + @TestMetadata("localFunctionNoInheritVisibility.kt") + public void testLocalFunctionNoInheritVisibility() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/localFunctionNoInheritVisibility.kt"); + } + + @Test + @TestMetadata("localObjectInInnerClass.kt") + public void testLocalObjectInInnerClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/localObjectInInnerClass.kt"); + } + + @Test + @TestMetadata("LocalVariableWithNoTypeInformation.kt") + public void testLocalVariableWithNoTypeInformation() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/LocalVariableWithNoTypeInformation.kt"); + } + + @Test + @TestMetadata("localVariablesWithTypeParameters_1_3.kt") + public void testLocalVariablesWithTypeParameters_1_3() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_3.kt"); + } + + @Test + @TestMetadata("localVariablesWithTypeParameters_1_4.kt") + public void testLocalVariablesWithTypeParameters_1_4() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_4.kt"); + } + + @Test + @TestMetadata("mappedFunctionNotImplemented.kt") + public void testMappedFunctionNotImplemented() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/mappedFunctionNotImplemented.kt"); + } + + @Test + @TestMetadata("mulitpleVarargParameters.kt") + public void testMulitpleVarargParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/mulitpleVarargParameters.kt"); + } + + @Test + @TestMetadata("MultiDeclarationErrors.kt") + public void testMultiDeclarationErrors() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/MultiDeclarationErrors.kt"); + } + + @Test + @TestMetadata("nameWithDangerousCharacters.kt") + public void testNameWithDangerousCharacters() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/nameWithDangerousCharacters.kt"); + } + + @Test + @TestMetadata("namedFunAsLastExpressionInBlock.kt") + public void testNamedFunAsLastExpressionInBlock() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.kt"); + } + + @Test + @TestMetadata("packageDeclarationModifiers.kt") + public void testPackageDeclarationModifiers() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/packageDeclarationModifiers.kt"); + } + + @Test + @TestMetadata("propertyInPackageHasNoInheritVisibility.kt") + public void testPropertyInPackageHasNoInheritVisibility() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/propertyInPackageHasNoInheritVisibility.kt"); + } + + @Test + @TestMetadata("RedeclarationsInMultiDecl.kt") + public void testRedeclarationsInMultiDecl() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/RedeclarationsInMultiDecl.kt"); + } + + @Test + @TestMetadata("ScalaLikeNamedFun.kt") + public void testScalaLikeNamedFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/ScalaLikeNamedFun.kt"); + } + + @Test + @TestMetadata("sealedOnMembers.kt") + public void testSealedOnMembers() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/sealedOnMembers.kt"); + } + + @Test + @TestMetadata("unambiguousObjectExpressionType.kt") + public void testUnambiguousObjectExpressionType() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/unambiguousObjectExpressionType.kt"); + } + + @Test + @TestMetadata("valVarFunctionParameter.kt") + public void testValVarFunctionParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/valVarFunctionParameter.kt"); + } + + @Test + @TestMetadata("VarianceOnFunctionAndPropertyTypeParameters.kt") + public void testVarianceOnFunctionAndPropertyTypeParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/VarianceOnFunctionAndPropertyTypeParameters.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations") + @TestDataPath("$PROJECT_ROOT") + public class DestructuringDeclarations { + @Test + public void testAllFilesPresentInDestructuringDeclarations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("destructuringDeclarationAssignedUnresolved.kt") + public void testDestructuringDeclarationAssignedUnresolved() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/destructuringDeclarationAssignedUnresolved.kt"); + } + + @Test + @TestMetadata("destructuringDeclarationMissingInitializer.kt") + public void testDestructuringDeclarationMissingInitializer() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/destructuringDeclarationMissingInitializer.kt"); + } + + @Test + @TestMetadata("DoubleDeclForLoop.kt") + public void testDoubleDeclForLoop() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/DoubleDeclForLoop.kt"); + } + + @Test + @TestMetadata("FolLoopTypeComponentTypeMismatch.kt") + public void testFolLoopTypeComponentTypeMismatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/FolLoopTypeComponentTypeMismatch.kt"); + } + + @Test + @TestMetadata("ForLoopComponentFunctionAmbiguity.kt") + public void testForLoopComponentFunctionAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopComponentFunctionAmbiguity.kt"); + } + + @Test + @TestMetadata("ForLoopComponentFunctionMissing.kt") + public void testForLoopComponentFunctionMissing() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopComponentFunctionMissing.kt"); + } + + @Test + @TestMetadata("ForLoopMissingLoopParameter.kt") + public void testForLoopMissingLoopParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopMissingLoopParameter.kt"); + } + + @Test + @TestMetadata("ForLoopWithExtensions.kt") + public void testForLoopWithExtensions() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopWithExtensions.kt"); + } + + @Test + @TestMetadata("ForWithExplicitTypes.kt") + public void testForWithExplicitTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForWithExplicitTypes.kt"); + } + + @Test + @TestMetadata("kt2829.kt") + public void testKt2829() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/kt2829.kt"); + } + + @Test + @TestMetadata("lastDestructuringDeclarationInBlock.kt") + public void testLastDestructuringDeclarationInBlock() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/lastDestructuringDeclarationInBlock.kt"); + } + + @Test + @TestMetadata("RedeclarationInForLoop.kt") + public void testRedeclarationInForLoop() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/RedeclarationInForLoop.kt"); + } + + @Test + @TestMetadata("SingleDeclForLoop.kt") + public void testSingleDeclForLoop() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/SingleDeclForLoop.kt"); + } + + @Test + @TestMetadata("underscore.kt") + public void testUnderscore() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/underscore.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction") + @TestDataPath("$PROJECT_ROOT") + public class FiniteBoundRestriction { + @Test + public void testAllFilesPresentInFiniteBoundRestriction() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("CasesWithOneTypeParameter.kt") + public void testCasesWithOneTypeParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction/CasesWithOneTypeParameter.kt"); + } + + @Test + @TestMetadata("CasesWithTwoTypeParameters.kt") + public void testCasesWithTwoTypeParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction/CasesWithTwoTypeParameters.kt"); + } + + @Test + @TestMetadata("JavaSuperType.kt") + public void testJavaSuperType() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction/JavaSuperType.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction") + @TestDataPath("$PROJECT_ROOT") + public class NonExpansiveInheritanceRestriction { + @Test + public void testAllFilesPresentInNonExpansiveInheritanceRestriction() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("JavaWithKotlin.kt") + public void testJavaWithKotlin() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction/JavaWithKotlin.kt"); + } + + @Test + @TestMetadata("JavaWithKotlin2.kt") + public void testJavaWithKotlin2() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction/JavaWithKotlin2.kt"); + } + + @Test + @TestMetadata("PureKotlin.kt") + public void testPureKotlin() throws Exception { + runTest("compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction/PureKotlin.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/defaultArguments") + @TestDataPath("$PROJECT_ROOT") + public class DefaultArguments { + @Test + public void testAllFilesPresentInDefaultArguments() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("kt5232.kt") + public void testKt5232() throws Exception { + runTest("compiler/testData/diagnostics/tests/defaultArguments/kt5232.kt"); + } + + @Test + @TestMetadata("superCall.kt") + public void testSuperCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/defaultArguments/superCall.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/delegatedProperty") + @TestDataPath("$PROJECT_ROOT") + public class DelegatedProperty { + @Test + @TestMetadata("absentErrorAboutInitializer.kt") + public void testAbsentErrorAboutInitializer() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/absentErrorAboutInitializer.kt"); + } + + @Test + @TestMetadata("absentErrorAboutType.kt") + public void testAbsentErrorAboutType() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/absentErrorAboutType.kt"); + } + + @Test + @TestMetadata("abstractDelegatedProperty.kt") + public void testAbstractDelegatedProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/abstractDelegatedProperty.kt"); + } + + @Test + public void testAllFilesPresentInDelegatedProperty() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("backingField.kt") + public void testBackingField() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/backingField.kt"); + } + + @Test + @TestMetadata("defaultGetter.kt") + public void testDefaultGetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/defaultGetter.kt"); + } + + @Test + @TestMetadata("defaultSetter.kt") + public void testDefaultSetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/defaultSetter.kt"); + } + + @Test + @TestMetadata("delegatedPropertyOverridedInTrait.kt") + public void testDelegatedPropertyOverridedInTrait() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/delegatedPropertyOverridedInTrait.kt"); + } + + @Test + @TestMetadata("delegatedPropertyOverridedInTraitTypeMismatch.kt") + public void testDelegatedPropertyOverridedInTraitTypeMismatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/delegatedPropertyOverridedInTraitTypeMismatch.kt"); + } + + @Test + @TestMetadata("disallowImplInTypeParameter.kt") + public void testDisallowImplInTypeParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/disallowImplInTypeParameter.kt"); + } + + @Test + @TestMetadata("genericGetter.kt") + public void testGenericGetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/genericGetter.kt"); + } + + @Test + @TestMetadata("getterWithSubtype.kt") + public void testGetterWithSubtype() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/getterWithSubtype.kt"); + } + + @Test + @TestMetadata("inTrait.kt") + public void testInTrait() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/inTrait.kt"); + } + + @Test + @TestMetadata("incompleteTypeInference.kt") + public void testIncompleteTypeInference() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/incompleteTypeInference.kt"); + } + + @Test + @TestMetadata("kt4640.kt") + public void testKt4640() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/kt4640.kt"); + } + + @Test + @TestMetadata("kt48546.kt") + public void testKt48546() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/kt48546.kt"); + } + + @Test + @TestMetadata("kt48546Strict.kt") + public void testKt48546Strict() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/kt48546Strict.kt"); + } + + @Test + @TestMetadata("localVariable.kt") + public void testLocalVariable() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/localVariable.kt"); + } + + @Test + @TestMetadata("localWithSmartCast.kt") + public void testLocalWithSmartCast() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/localWithSmartCast.kt"); + } + + @Test + @TestMetadata("missedGetter.kt") + public void testMissedGetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/missedGetter.kt"); + } + + @Test + @TestMetadata("missedSetter.kt") + public void testMissedSetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/missedSetter.kt"); + } + + @Test + @TestMetadata("nonDefaultAccessors.kt") + public void testNonDefaultAccessors() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/nonDefaultAccessors.kt"); + } + + @Test + @TestMetadata("propertyDefferedType.kt") + public void testPropertyDefferedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/propertyDefferedType.kt"); + } + + @Test + @TestMetadata("recursiveType.kt") + public void testRecursiveType() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.kt"); + } + + @Test + @TestMetadata("redundantGetter.kt") + public void testRedundantGetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/redundantGetter.kt"); + } + + @Test + @TestMetadata("redundantSetter.kt") + public void testRedundantSetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/redundantSetter.kt"); + } + + @Test + @TestMetadata("setterThisTypeMismatch.kt") + public void testSetterThisTypeMismatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/setterThisTypeMismatch.kt"); + } + + @Test + @TestMetadata("setterWithSupertype.kt") + public void testSetterWithSupertype() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/setterWithSupertype.kt"); + } + + @Test + @TestMetadata("severalReceivers.kt") + public void testSeveralReceivers() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/severalReceivers.kt"); + } + + @Test + @TestMetadata("thisInDelegate.kt") + public void testThisInDelegate() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/thisInDelegate.kt"); + } + + @Test + @TestMetadata("thisOfAnyType.kt") + public void testThisOfAnyType() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/thisOfAnyType.kt"); + } + + @Test + @TestMetadata("thisOfNothingNullableType.kt") + public void testThisOfNothingNullableType() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingNullableType.kt"); + } + + @Test + @TestMetadata("thisOfNothingType.kt") + public void testThisOfNothingType() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingType.kt"); + } + + @Test + @TestMetadata("twoGetMethods.kt") + public void testTwoGetMethods() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/twoGetMethods.kt"); + } + + @Test + @TestMetadata("typeMismatchForGetReturnType.kt") + public void testTypeMismatchForGetReturnType() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForGetReturnType.kt"); + } + + @Test + @TestMetadata("typeMismatchForGetWithGeneric.kt") + public void testTypeMismatchForGetWithGeneric() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForGetWithGeneric.kt"); + } + + @Test + @TestMetadata("typeMismatchForSetParameter.kt") + public void testTypeMismatchForSetParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForSetParameter.kt"); + } + + @Test + @TestMetadata("typeMismatchForThisGetParameter.kt") + public void testTypeMismatchForThisGetParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForThisGetParameter.kt"); + } + + @Test + @TestMetadata("useTypeParameterOfExtensionProperty.kt") + public void testUseTypeParameterOfExtensionProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/useTypeParameterOfExtensionProperty.kt"); + } + + @Test + @TestMetadata("useTypeParameterOfExtensionProperty2.kt") + public void testUseTypeParameterOfExtensionProperty2() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/useTypeParameterOfExtensionProperty2.kt"); + } + + @Test + @TestMetadata("useTypeParameterOfExtensionProperty_Disabled.kt") + public void testUseTypeParameterOfExtensionProperty_Disabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/useTypeParameterOfExtensionProperty_Disabled.kt"); + } + + @Test + @TestMetadata("wrongCountOfParametersInGet.kt") + public void testWrongCountOfParametersInGet() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/wrongCountOfParametersInGet.kt"); + } + + @Test + @TestMetadata("wrongCountOfParametersInSet.kt") + public void testWrongCountOfParametersInSet() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/wrongCountOfParametersInSet.kt"); + } + + @Test + @TestMetadata("wrongSetterReturnType.kt") + public void testWrongSetterReturnType() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/wrongSetterReturnType.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/delegatedProperty/inference") + @TestDataPath("$PROJECT_ROOT") + public class Inference { + @Test + public void testAllFilesPresentInInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegatedProperty/inference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("callableReferenceArgumentInDelegatedExpression.kt") + public void testCallableReferenceArgumentInDelegatedExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/callableReferenceArgumentInDelegatedExpression.kt"); + } + + @Test + @TestMetadata("delegateExpressionAsLambda.kt") + public void testDelegateExpressionAsLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/delegateExpressionAsLambda.kt"); + } + + @Test + @TestMetadata("delegatedExpressionWithLabeledReturnInsideLambda.kt") + public void testDelegatedExpressionWithLabeledReturnInsideLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/delegatedExpressionWithLabeledReturnInsideLambda.kt"); + } + + @Test + @TestMetadata("differentDelegatedExpressions.kt") + public void testDifferentDelegatedExpressions() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/differentDelegatedExpressions.kt"); + } + + @Test + @TestMetadata("extensionGet.kt") + public void testExtensionGet() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/extensionGet.kt"); + } + + @Test + @TestMetadata("extensionProperty.kt") + public void testExtensionProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/extensionProperty.kt"); + } + + @Test + @TestMetadata("genericMethodInGenericClass.kt") + public void testGenericMethodInGenericClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethodInGenericClass.kt"); + } + + @Test + @TestMetadata("genericMethods.kt") + public void testGenericMethods() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethods.kt"); + } + + @Test + @TestMetadata("kt41952.kt") + public void testKt41952() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/kt41952.kt"); + } + + @Test + @TestMetadata("labeledDelegatedExpression.kt") + public void testLabeledDelegatedExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/labeledDelegatedExpression.kt"); + } + + @Test + @TestMetadata("manyIncompleteCandidates.kt") + public void testManyIncompleteCandidates() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/manyIncompleteCandidates.kt"); + } + + @Test + @TestMetadata("noErrorsForImplicitConstraints.kt") + public void testNoErrorsForImplicitConstraints() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/noErrorsForImplicitConstraints.kt"); + } + + @Test + @TestMetadata("noExpectedTypeForSupertypeConstraint.kt") + public void testNoExpectedTypeForSupertypeConstraint() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/noExpectedTypeForSupertypeConstraint.kt"); + } + + @Test + @TestMetadata("resultTypeOfLambdaForConventionMethods.kt") + public void testResultTypeOfLambdaForConventionMethods() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/resultTypeOfLambdaForConventionMethods.kt"); + } + + @Test + @TestMetadata("typeOfLazyDelegatedPropertyWithObject.kt") + public void testTypeOfLazyDelegatedPropertyWithObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/typeOfLazyDelegatedPropertyWithObject.kt"); + } + + @Test + @TestMetadata("useCompleterWithoutExpectedType.kt") + public void testUseCompleterWithoutExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/useCompleterWithoutExpectedType.kt"); + } + + @Test + @TestMetadata("useExpectedType.kt") + public void testUseExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/useExpectedType.kt"); + } + + @Test + @TestMetadata("useExpectedTypeForVal.kt") + public void testUseExpectedTypeForVal() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/useExpectedTypeForVal.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate") + @TestDataPath("$PROJECT_ROOT") + public class ProvideDelegate { + @Test + public void testAllFilesPresentInProvideDelegate() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("commonCaseForInference.kt") + public void testCommonCaseForInference() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/commonCaseForInference.kt"); + } + + @Test + @TestMetadata("genericProvideDelegate.kt") + public void testGenericProvideDelegate() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/genericProvideDelegate.kt"); + } + + @Test + @TestMetadata("hostAndReceiver1.kt") + public void testHostAndReceiver1() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver1.kt"); + } + + @Test + @TestMetadata("hostAndReceiver2.kt") + public void testHostAndReceiver2() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver2.kt"); + } + + @Test + @TestMetadata("hostAndReceiver3.kt") + public void testHostAndReceiver3() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver3.kt"); + } + + @Test + @TestMetadata("inferenceFromReceiver1.kt") + public void testInferenceFromReceiver1() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/inferenceFromReceiver1.kt"); + } + + @Test + @TestMetadata("inferenceFromReceiver2.kt") + public void testInferenceFromReceiver2() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/inferenceFromReceiver2.kt"); + } + + @Test + @TestMetadata("kt38714.kt") + public void testKt38714() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/kt38714.kt"); + } + + @Test + @TestMetadata("localDelegatedProperty.kt") + public void testLocalDelegatedProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/localDelegatedProperty.kt"); + } + + @Test + @TestMetadata("noOperatorModifierOnProvideDelegate.kt") + public void testNoOperatorModifierOnProvideDelegate() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/noOperatorModifierOnProvideDelegate.kt"); + } + + @Test + @TestMetadata("overloadResolutionForSeveralProvideDelegates.kt") + public void testOverloadResolutionForSeveralProvideDelegates() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/overloadResolutionForSeveralProvideDelegates.kt"); + } + + @Test + @TestMetadata("provideDelegateOnFunctionalTypeWithThis.kt") + public void testProvideDelegateOnFunctionalTypeWithThis() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/provideDelegateOnFunctionalTypeWithThis.kt"); + } + + @Test + @TestMetadata("provideDelegateOperatorDeclaration.kt") + public void testProvideDelegateOperatorDeclaration() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/provideDelegateOperatorDeclaration.kt"); + } + + @Test + @TestMetadata("provideDelegateResolutionWithStubTypes.kt") + public void testProvideDelegateResolutionWithStubTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/provideDelegateResolutionWithStubTypes.kt"); + } + + @Test + @TestMetadata("setValue.kt") + public void testSetValue() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/setValue.kt"); + } + + @Test + @TestMetadata("simpleProvideDelegate.kt") + public void testSimpleProvideDelegate() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/simpleProvideDelegate.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/delegation") + @TestDataPath("$PROJECT_ROOT") + public class Delegation { + @Test + public void testAllFilesPresentInDelegation() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("DelegationAndOverriding.kt") + public void testDelegationAndOverriding() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/DelegationAndOverriding.kt"); + } + + @Test + @TestMetadata("DelegationExpectedType.kt") + public void testDelegationExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/DelegationExpectedType.kt"); + } + + @Test + @TestMetadata("DelegationNotTotrait.kt") + public void testDelegationNotTotrait() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/DelegationNotTotrait.kt"); + } + + @Test + @TestMetadata("DelegationToJavaIface.kt") + public void testDelegationToJavaIface() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/DelegationToJavaIface.kt"); + } + + @Test + @TestMetadata("Delegation_ClashingFunctions.kt") + public void testDelegation_ClashingFunctions() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/Delegation_ClashingFunctions.kt"); + } + + @Test + @TestMetadata("Delegation_Hierarchy.kt") + public void testDelegation_Hierarchy() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/Delegation_Hierarchy.kt"); + } + + @Test + @TestMetadata("Delegation_MultipleDelegates.kt") + public void testDelegation_MultipleDelegates() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/Delegation_MultipleDelegates.kt"); + } + + @Test + @TestMetadata("Delegation_ScopeInitializationOrder.kt") + public void testDelegation_ScopeInitializationOrder() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/Delegation_ScopeInitializationOrder.kt"); + } + + @Test + @TestMetadata("kt40510.kt") + public void testKt40510() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/kt40510.kt"); + } + + @Test + @TestMetadata("kt44843.kt") + public void testKt44843() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/kt44843.kt"); + } + + @Test + @TestMetadata("kt48546.kt") + public void testKt48546() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/kt48546.kt"); + } + + @Test + @TestMetadata("kt49477.kt") + public void testKt49477() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/kt49477.kt"); + } + + @Test + @TestMetadata("kt49477Error.kt") + public void testKt49477Error() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/kt49477Error.kt"); + } + + @Test + @TestMetadata("kt8154.kt") + public void testKt8154() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/kt8154.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/delegation/clashes") + @TestDataPath("$PROJECT_ROOT") + public class Clashes { + @Test + public void testAllFilesPresentInClashes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation/clashes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("finalMemberOverridden.kt") + public void testFinalMemberOverridden() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/clashes/finalMemberOverridden.kt"); + } + + @Test + @TestMetadata("propertyTypeMismatch.kt") + public void testPropertyTypeMismatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/clashes/propertyTypeMismatch.kt"); + } + + @Test + @TestMetadata("returnTypeMismatch.kt") + public void testReturnTypeMismatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/clashes/returnTypeMismatch.kt"); + } + + @Test + @TestMetadata("varOverriddenByVal.kt") + public void testVarOverriddenByVal() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/clashes/varOverriddenByVal.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/delegation/covariantOverrides") + @TestDataPath("$PROJECT_ROOT") + public class CovariantOverrides { + @Test + public void testAllFilesPresentInCovariantOverrides() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation/covariantOverrides"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("fromClass.kt") + public void testFromClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/covariantOverrides/fromClass.kt"); + } + + @Test + @TestMetadata("irrelevant.kt") + public void testIrrelevant() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/covariantOverrides/irrelevant.kt"); + } + + @Test + @TestMetadata("kt13952.kt") + public void testKt13952() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/covariantOverrides/kt13952.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/covariantOverrides/simple.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride") + @TestDataPath("$PROJECT_ROOT") + public class MemberHidesSupertypeOverride { + @Test + @TestMetadata("abstractOverride.kt") + public void testAbstractOverride() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/abstractOverride.kt"); + } + + @Test + public void testAllFilesPresentInMemberHidesSupertypeOverride() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("delegationToSubType.kt") + public void testDelegationToSubType() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/delegationToSubType.kt"); + } + + @Test + @TestMetadata("delegationToSubTypeProperty.kt") + public void testDelegationToSubTypeProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/delegationToSubTypeProperty.kt"); + } + + @Test + @TestMetadata("delegationToSubTypeWithOverride.kt") + public void testDelegationToSubTypeWithOverride() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/delegationToSubTypeWithOverride.kt"); + } + + @Test + @TestMetadata("delegationToSubTypeWithOverrideProperty.kt") + public void testDelegationToSubTypeWithOverrideProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/delegationToSubTypeWithOverrideProperty.kt"); + } + + @Test + @TestMetadata("diamond.kt") + public void testDiamond() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/diamond.kt"); + } + + @Test + @TestMetadata("explicitOverride.kt") + public void testExplicitOverride() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/explicitOverride.kt"); + } + + @Test + @TestMetadata("fakeOverrideInTheMiddle.kt") + public void testFakeOverrideInTheMiddle() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/fakeOverrideInTheMiddle.kt"); + } + + @Test + @TestMetadata("generic.kt") + public void testGeneric() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/generic.kt"); + } + + @Test + @TestMetadata("sameDelegationInHierarchy.kt") + public void testSameDelegationInHierarchy() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/sameDelegationInHierarchy.kt"); + } + + @Test + @TestMetadata("sameDelegationInHierarchy2.kt") + public void testSameDelegationInHierarchy2() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/sameDelegationInHierarchy2.kt"); + } + + @Test + @TestMetadata("severalDelegates.kt") + public void testSeveralDelegates() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/severalDelegates.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/simple.kt"); + } + + @Test + @TestMetadata("simpleNoOverride.kt") + public void testSimpleNoOverride() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/simpleNoOverride.kt"); + } + + @Test + @TestMetadata("simpleProp.kt") + public void testSimpleProp() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/simpleProp.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/deparenthesize") + @TestDataPath("$PROJECT_ROOT") + public class Deparenthesize { + @Test + public void testAllFilesPresentInDeparenthesize() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("annotatedSafeCall.kt") + public void testAnnotatedSafeCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/deparenthesize/annotatedSafeCall.kt"); + } + + @Test + @TestMetadata("checkDeparenthesizedType.kt") + public void testCheckDeparenthesizedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/deparenthesize/checkDeparenthesizedType.kt"); + } + + @Test + @TestMetadata("labeledSafeCall.kt") + public void testLabeledSafeCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/deparenthesize/labeledSafeCall.kt"); + } + + @Test + @TestMetadata("multiParenthesizedSafeCall.kt") + public void testMultiParenthesizedSafeCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/deparenthesize/multiParenthesizedSafeCall.kt"); + } + + @Test + @TestMetadata("parenthesizedSafeCall.kt") + public void testParenthesizedSafeCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/deparenthesize/parenthesizedSafeCall.kt"); + } + + @Test + @TestMetadata("ParenthesizedVariable.kt") + public void testParenthesizedVariable() throws Exception { + runTest("compiler/testData/diagnostics/tests/deparenthesize/ParenthesizedVariable.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/deprecated") + @TestDataPath("$PROJECT_ROOT") + public class Deprecated { + @Test + public void testAllFilesPresentInDeprecated() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/deprecated"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("annotationUsage.kt") + public void testAnnotationUsage() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/annotationUsage.kt"); + } + + @Test + @TestMetadata("candidateBehindHiddenPropertyAccessors.kt") + public void testCandidateBehindHiddenPropertyAccessors() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/candidateBehindHiddenPropertyAccessors.kt"); + } + + @Test + @TestMetadata("classWithCompanionObject.kt") + public void testClassWithCompanionObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/classWithCompanionObject.kt"); + } + + @Test + @TestMetadata("companionObjectUsage.kt") + public void testCompanionObjectUsage() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/companionObjectUsage.kt"); + } + + @Test + @TestMetadata("componentUsage.kt") + public void testComponentUsage() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/componentUsage.kt"); + } + + @Test + @TestMetadata("deprecatedCompanionAndClassReference.kt") + public void testDeprecatedCompanionAndClassReference() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedCompanionAndClassReference.kt"); + } + + @Test + @TestMetadata("deprecatedConstructor.kt") + public void testDeprecatedConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedConstructor.kt"); + } + + @Test + @TestMetadata("deprecatedError.kt") + public void testDeprecatedError() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedError.kt"); + } + + @Test + @TestMetadata("deprecatedErrorBuilder.kt") + public void testDeprecatedErrorBuilder() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedErrorBuilder.kt"); + } + + @Test + @TestMetadata("deprecatedHidden.kt") + public void testDeprecatedHidden() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedHidden.kt"); + } + + @Test + @TestMetadata("deprecatedHiddenOnCallableReferenceArgument.kt") + public void testDeprecatedHiddenOnCallableReferenceArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedHiddenOnCallableReferenceArgument.kt"); + } + + @Test + @TestMetadata("deprecatedInheritance_after.kt") + public void testDeprecatedInheritance_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedInheritance_after.kt"); + } + + @Test + @TestMetadata("deprecatedInheritance_before.kt") + public void testDeprecatedInheritance_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedInheritance_before.kt"); + } + + @Test + @TestMetadata("deprecatedPropertyInheritance_after.kt") + public void testDeprecatedPropertyInheritance_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedPropertyInheritance_after.kt"); + } + + @Test + @TestMetadata("deprecatedPropertyInheritance_before.kt") + public void testDeprecatedPropertyInheritance_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedPropertyInheritance_before.kt"); + } + + @Test + @TestMetadata("duplicatedOverrideDeprecationOnProperty.kt") + public void testDuplicatedOverrideDeprecationOnProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/duplicatedOverrideDeprecationOnProperty.kt"); + } + + @Test + @TestMetadata("functionUsage.kt") + public void testFunctionUsage() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/functionUsage.kt"); + } + + @Test + @TestMetadata("genericConstructorUsage.kt") + public void testGenericConstructorUsage() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/genericConstructorUsage.kt"); + } + + @Test + @TestMetadata("hiddenPropertyAccessors.kt") + public void testHiddenPropertyAccessors() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/hiddenPropertyAccessors.kt"); + } + + @Test + @TestMetadata("importJavaSamInterface.kt") + public void testImportJavaSamInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/importJavaSamInterface.kt"); + } + + @Test + @TestMetadata("imports.kt") + public void testImports() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/imports.kt"); + } + + @Test + @TestMetadata("iteratorUsage.kt") + public void testIteratorUsage() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/iteratorUsage.kt"); + } + + @Test + @TestMetadata("javaDeprecated.kt") + public void testJavaDeprecated() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/javaDeprecated.kt"); + } + + @Test + @TestMetadata("javaDeprecatedInheritance.kt") + public void testJavaDeprecatedInheritance() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/javaDeprecatedInheritance.kt"); + } + + @Test + @TestMetadata("javaDocDeprecated.kt") + public void testJavaDocDeprecated() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/javaDocDeprecated.kt"); + } + + @Test + @TestMetadata("nestedTypesUsage.kt") + public void testNestedTypesUsage() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/nestedTypesUsage.kt"); + } + + @Test + @TestMetadata("objectUsage.kt") + public void testObjectUsage() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/objectUsage.kt"); + } + + @Test + @TestMetadata("propertyUsage.kt") + public void testPropertyUsage() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/propertyUsage.kt"); + } + + @Test + @TestMetadata("propertyUseSiteTargetedAnnotations.kt") + public void testPropertyUseSiteTargetedAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/propertyUseSiteTargetedAnnotations.kt"); + } + + @Test + @TestMetadata("propertyWithInvoke.kt") + public void testPropertyWithInvoke() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/propertyWithInvoke.kt"); + } + + @Test + @TestMetadata("thisUsage.kt") + public void testThisUsage() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/thisUsage.kt"); + } + + @Test + @TestMetadata("typeUsage.kt") + public void testTypeUsage() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/typeUsage.kt"); + } + + @Test + @TestMetadata("typealiasCompanionObject.kt") + public void testTypealiasCompanionObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/typealiasCompanionObject.kt"); + } + + @Test + @TestMetadata("typealiasConstructor.kt") + public void testTypealiasConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/typealiasConstructor.kt"); + } + + @Test + @TestMetadata("typealiasForDeprecatedClass.kt") + public void testTypealiasForDeprecatedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/typealiasForDeprecatedClass.kt"); + } + + @Test + @TestMetadata("typealiasUsage.kt") + public void testTypealiasUsage() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/typealiasUsage.kt"); + } + + @Test + @TestMetadata("unusedImport.kt") + public void testUnusedImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/unusedImport.kt"); + } + + @Test + @TestMetadata("usageOnEnum.kt") + public void testUsageOnEnum() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/usageOnEnum.kt"); + } + + @Test + @TestMetadata("warningOnConstructorErrorOnClass.kt") + public void testWarningOnConstructorErrorOnClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/warningOnConstructorErrorOnClass.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin") + @TestDataPath("$PROJECT_ROOT") + public class DeprecatedSinceKotlin { + @Test + public void testAllFilesPresentInDeprecatedSinceKotlin() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("checkValuesAreParseableAsVersion.kt") + public void testCheckValuesAreParseableAsVersion() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/checkValuesAreParseableAsVersion.kt"); + } + + @Test + @TestMetadata("deprecatedSinceKotlinDeclaration.kt") + public void testDeprecatedSinceKotlinDeclaration() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/deprecatedSinceKotlinDeclaration.kt"); + } + + @Test + @TestMetadata("deprecatedSinceKotlinHiddenOnReferenceArgument.kt") + public void testDeprecatedSinceKotlinHiddenOnReferenceArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/deprecatedSinceKotlinHiddenOnReferenceArgument.kt"); + } + + @Test + @TestMetadata("deprecatedSinceKotlinOutsideKotlinPackage.kt") + public void testDeprecatedSinceKotlinOutsideKotlinPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/deprecatedSinceKotlinOutsideKotlinPackage.kt"); + } + + @Test + @TestMetadata("deprecatedSinceKotlinWithoutArguments.kt") + public void testDeprecatedSinceKotlinWithoutArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/deprecatedSinceKotlinWithoutArguments.kt"); + } + + @Test + @TestMetadata("error.kt") + public void testError() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/error.kt"); + } + + @Test + @TestMetadata("hidden.kt") + public void testHidden() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/hidden.kt"); + } + + @Test + @TestMetadata("messageFromDeprecatedAnnotation.kt") + public void testMessageFromDeprecatedAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/messageFromDeprecatedAnnotation.kt"); + } + + @Test + @TestMetadata("warning.kt") + public void testWarning() throws Exception { + runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/warning.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature") + @TestDataPath("$PROJECT_ROOT") + public class DuplicateJvmSignature { + @Test + public void testAllFilesPresentInDuplicateJvmSignature() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("caseInProperties.kt") + public void testCaseInProperties() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/caseInProperties.kt"); + } + + @Test + @TestMetadata("missingNames.kt") + public void testMissingNames() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/missingNames.kt"); + } + + @Test + @TestMetadata("vararg.kt") + public void testVararg() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/vararg.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides") + @TestDataPath("$PROJECT_ROOT") + public class AccidentalOverrides { + @Test + @TestMetadata("accidentalOverrideFromGrandparent.kt") + public void testAccidentalOverrideFromGrandparent() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/accidentalOverrideFromGrandparent.kt"); + } + + @Test + public void testAllFilesPresentInAccidentalOverrides() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("classFunctionOverriddenByProperty.kt") + public void testClassFunctionOverriddenByProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByProperty.kt"); + } + + @Test + @TestMetadata("classFunctionOverriddenByPropertyInConstructor.kt") + public void testClassFunctionOverriddenByPropertyInConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByPropertyInConstructor.kt"); + } + + @Test + @TestMetadata("classFunctionOverriddenByPropertyNoGetter.kt") + public void testClassFunctionOverriddenByPropertyNoGetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByPropertyNoGetter.kt"); + } + + @Test + @TestMetadata("classPropertyOverriddenByFunction.kt") + public void testClassPropertyOverriddenByFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classPropertyOverriddenByFunction.kt"); + } + + @Test + @TestMetadata("defaultFunction.kt") + public void testDefaultFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/defaultFunction.kt"); + } + + @Test + @TestMetadata("delegatedFunctionOverriddenByProperty.kt") + public void testDelegatedFunctionOverriddenByProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/delegatedFunctionOverriddenByProperty.kt"); + } + + @Test + @TestMetadata("genericClassFunction.kt") + public void testGenericClassFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/genericClassFunction.kt"); + } + + @Test + @TestMetadata("overridesNothing.kt") + public void testOverridesNothing() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/overridesNothing.kt"); + } + + @Test + @TestMetadata("privateClassFunctionOverriddenByProperty.kt") + public void testPrivateClassFunctionOverriddenByProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/privateClassFunctionOverriddenByProperty.kt"); + } + + @Test + @TestMetadata("require.kt") + public void testRequire() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/require.kt"); + } + + @Test + @TestMetadata("traitFunctionOverriddenByProperty.kt") + public void testTraitFunctionOverriddenByProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByProperty.kt"); + } + + @Test + @TestMetadata("traitFunctionOverriddenByPropertyNoImpl.kt") + public void testTraitFunctionOverriddenByPropertyNoImpl() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByPropertyNoImpl.kt"); + } + + @Test + @TestMetadata("traitPropertyOverriddenByFunction.kt") + public void testTraitPropertyOverriddenByFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunction.kt"); + } + + @Test + @TestMetadata("traitPropertyOverriddenByFunctionNoImpl.kt") + public void testTraitPropertyOverriddenByFunctionNoImpl() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunctionNoImpl.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/bridges") + @TestDataPath("$PROJECT_ROOT") + public class Bridges { + @Test + public void testAllFilesPresentInBridges() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/bridges"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("class.kt") + public void testClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/bridges/class.kt"); + } + + @Test + @TestMetadata("fakeOverrideTrait.kt") + public void testFakeOverrideTrait() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/bridges/fakeOverrideTrait.kt"); + } + + @Test + @TestMetadata("trait.kt") + public void testTrait() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/bridges/trait.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure") + @TestDataPath("$PROJECT_ROOT") + public class Erasure { + @Test + public void testAllFilesPresentInErasure() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("clashFromInterfaceAndSuperClass.kt") + public void testClashFromInterfaceAndSuperClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/clashFromInterfaceAndSuperClass.kt"); + } + + @Test + @TestMetadata("collections.kt") + public void testCollections() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/collections.kt"); + } + + @Test + @TestMetadata("delegateToTwoTraits.kt") + public void testDelegateToTwoTraits() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/delegateToTwoTraits.kt"); + } + + @Test + @TestMetadata("delegationAndOwnMethod.kt") + public void testDelegationAndOwnMethod() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/delegationAndOwnMethod.kt"); + } + + @Test + @TestMetadata("delegationToTraitImplAndOwnMethod.kt") + public void testDelegationToTraitImplAndOwnMethod() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/delegationToTraitImplAndOwnMethod.kt"); + } + + @Test + @TestMetadata("extensionProperties.kt") + public void testExtensionProperties() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/extensionProperties.kt"); + } + + @Test + @TestMetadata("genericType.kt") + public void testGenericType() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/genericType.kt"); + } + + @Test + @TestMetadata("inheritFromTwoTraits.kt") + public void testInheritFromTwoTraits() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/inheritFromTwoTraits.kt"); + } + + @Test + @TestMetadata("kotlinAndJavaCollections.kt") + public void testKotlinAndJavaCollections() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/kotlinAndJavaCollections.kt"); + } + + @Test + @TestMetadata("nullableType.kt") + public void testNullableType() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/nullableType.kt"); + } + + @Test + @TestMetadata("superTraitAndDelegationToTraitImpl.kt") + public void testSuperTraitAndDelegationToTraitImpl() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/superTraitAndDelegationToTraitImpl.kt"); + } + + @Test + @TestMetadata("twoTraitsAndOwnFunction.kt") + public void testTwoTraitsAndOwnFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/twoTraitsAndOwnFunction.kt"); + } + + @Test + @TestMetadata("typeMappedToJava.kt") + public void testTypeMappedToJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeMappedToJava.kt"); + } + + @Test + @TestMetadata("typeParameter.kt") + public void testTypeParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameter.kt"); + } + + @Test + @TestMetadata("typeParameterWithBound.kt") + public void testTypeParameterWithBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithBound.kt"); + } + + @Test + @TestMetadata("typeParameterWithTwoBounds.kt") + public void testTypeParameterWithTwoBounds() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithTwoBounds.kt"); + } + + @Test + @TestMetadata("typeParameterWithTwoBoundsInWhere.kt") + public void testTypeParameterWithTwoBoundsInWhere() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithTwoBoundsInWhere.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/finalMembersFromBuiltIns") + @TestDataPath("$PROJECT_ROOT") + public class FinalMembersFromBuiltIns { + @Test + public void testAllFilesPresentInFinalMembersFromBuiltIns() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/finalMembersFromBuiltIns"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("enumMembers.kt") + public void testEnumMembers() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/finalMembersFromBuiltIns/enumMembers.kt"); + } + + @Test + @TestMetadata("waitNotifyGetClass.kt") + public void testWaitNotifyGetClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/finalMembersFromBuiltIns/waitNotifyGetClass.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty") + @TestDataPath("$PROJECT_ROOT") + public class FunctionAndProperty { + @Test + public void testAllFilesPresentInFunctionAndProperty() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("class.kt") + public void testClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/class.kt"); + } + + @Test + @TestMetadata("classObject.kt") + public void testClassObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/classObject.kt"); + } + + @Test + @TestMetadata("classPropertyInConstructor.kt") + public void testClassPropertyInConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/classPropertyInConstructor.kt"); + } + + @Test + @TestMetadata("extensionFunctionAndNormalFunction.kt") + public void testExtensionFunctionAndNormalFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/extensionFunctionAndNormalFunction.kt"); + } + + @Test + @TestMetadata("extensionPropertyAndFunction.kt") + public void testExtensionPropertyAndFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/extensionPropertyAndFunction.kt"); + } + + @Test + @TestMetadata("functionAndSetter.kt") + public void testFunctionAndSetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/functionAndSetter.kt"); + } + + @Test + @TestMetadata("functionAndVar.kt") + public void testFunctionAndVar() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/functionAndVar.kt"); + } + + @Test + @TestMetadata("localClass.kt") + public void testLocalClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/localClass.kt"); + } + + @Test + @TestMetadata("localClassInClass.kt") + public void testLocalClassInClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/localClassInClass.kt"); + } + + @Test + @TestMetadata("nestedClass.kt") + public void testNestedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/nestedClass.kt"); + } + + @Test + @TestMetadata("object.kt") + public void testObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/object.kt"); + } + + @Test + @TestMetadata("objectExpression.kt") + public void testObjectExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/objectExpression.kt"); + } + + @Test + @TestMetadata("objectExpressionInConstructor.kt") + public void testObjectExpressionInConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/objectExpressionInConstructor.kt"); + } + + @Test + @TestMetadata("privateClassPropertyNoClash.kt") + public void testPrivateClassPropertyNoClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/privateClassPropertyNoClash.kt"); + } + + @Test + @TestMetadata("topLevel.kt") + public void testTopLevel() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevel.kt"); + } + + @Test + @TestMetadata("topLevelDifferentFiles.kt") + public void testTopLevelDifferentFiles() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevelDifferentFiles.kt"); + } + + @Test + @TestMetadata("topLevelGetter.kt") + public void testTopLevelGetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevelGetter.kt"); + } + + @Test + @TestMetadata("trait.kt") + public void testTrait() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/trait.kt"); + } + + @Test + @TestMetadata("withErrorTypes.kt") + public void testWithErrorTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/withErrorTypes.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames") + @TestDataPath("$PROJECT_ROOT") + public class SpecialNames { + @Test + public void testAllFilesPresentInSpecialNames() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("classObject.kt") + public void testClassObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObject.kt"); + } + + @Test + @TestMetadata("classObjectCopiedField.kt") + public void testClassObjectCopiedField() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObjectCopiedField.kt"); + } + + @Test + @TestMetadata("classObjectCopiedFieldObject.kt") + public void testClassObjectCopiedFieldObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObjectCopiedFieldObject.kt"); + } + + @Test + @TestMetadata("dataClassCopy.kt") + public void testDataClassCopy() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/dataClassCopy.kt"); + } + + @Test + @TestMetadata("delegationBy.kt") + public void testDelegationBy() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/delegationBy.kt"); + } + + @Test + @TestMetadata("enum.kt") + public void testEnum() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/enum.kt"); + } + + @Test + @TestMetadata("innerClassField.kt") + public void testInnerClassField() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/innerClassField.kt"); + } + + @Test + @TestMetadata("instance.kt") + public void testInstance() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/instance.kt"); + } + + @Test + @TestMetadata("propertyMetadataCache.kt") + public void testPropertyMetadataCache() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/propertyMetadataCache.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics") + @TestDataPath("$PROJECT_ROOT") + public class Statics { + @Test + public void testAllFilesPresentInStatics() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("jkjk.kt") + public void testJkjk() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jkjk.kt"); + } + + @Test + @TestMetadata("kotlinClassExtendsJavaClass.kt") + public void testKotlinClassExtendsJavaClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinClassExtendsJavaClass.kt"); + } + + @Test + @TestMetadata("kotlinClassExtendsJavaClassExtendsJavaClass.kt") + public void testKotlinClassExtendsJavaClassExtendsJavaClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinClassExtendsJavaClassExtendsJavaClass.kt"); + } + + @Test + @TestMetadata("kotlinClassImplementsJavaInterface.kt") + public void testKotlinClassImplementsJavaInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinClassImplementsJavaInterface.kt"); + } + + @Test + @TestMetadata("kotlinClassImplementsJavaInterfaceExtendsJavaInteface.kt") + public void testKotlinClassImplementsJavaInterfaceExtendsJavaInteface() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinClassImplementsJavaInterfaceExtendsJavaInteface.kt"); + } + + @Test + @TestMetadata("kotlinMembersVsJavaNonVisibleStatics.kt") + public void testKotlinMembersVsJavaNonVisibleStatics() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/synthesized") + @TestDataPath("$PROJECT_ROOT") + public class Synthesized { + @Test + public void testAllFilesPresentInSynthesized() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/synthesized"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("enumValuesValueOf.kt") + public void testEnumValuesValueOf() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/synthesized/enumValuesValueOf.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl") + @TestDataPath("$PROJECT_ROOT") + public class TraitImpl { + @Test + public void testAllFilesPresentInTraitImpl() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("oneTrait.kt") + public void testOneTrait() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl/oneTrait.kt"); + } + + @Test + @TestMetadata("traitFunctionOverriddenByPropertyInTrait.kt") + public void testTraitFunctionOverriddenByPropertyInTrait() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl/traitFunctionOverriddenByPropertyInTrait.kt"); + } + + @Test + @TestMetadata("traitPropertyOverriddenByFunctionInTrait.kt") + public void testTraitPropertyOverriddenByFunctionInTrait() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl/traitPropertyOverriddenByFunctionInTrait.kt"); + } + + @Test + @TestMetadata("twoTraits.kt") + public void testTwoTraits() throws Exception { + runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl/twoTraits.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/dynamicTypes") + @TestDataPath("$PROJECT_ROOT") + public class DynamicTypes { + @Test + public void testAllFilesPresentInDynamicTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dynamicTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("delegationBy.kt") + public void testDelegationBy() throws Exception { + runTest("compiler/testData/diagnostics/tests/dynamicTypes/delegationBy.kt"); + } + + @Test + @TestMetadata("unsupported.kt") + public void testUnsupported() throws Exception { + runTest("compiler/testData/diagnostics/tests/dynamicTypes/unsupported.kt"); + } + + @Test + @TestMetadata("withInvisibleSynthesized.kt") + public void testWithInvisibleSynthesized() throws Exception { + runTest("compiler/testData/diagnostics/tests/dynamicTypes/withInvisibleSynthesized.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/enum") + @TestDataPath("$PROJECT_ROOT") + public class Enum { + @Test + @TestMetadata("AbstractEnum.kt") + public void testAbstractEnum() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/AbstractEnum.kt"); + } + + @Test + @TestMetadata("AbstractInEnum.kt") + public void testAbstractInEnum() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/AbstractInEnum.kt"); + } + + @Test + @TestMetadata("AbstractOverrideInEnum.kt") + public void testAbstractOverrideInEnum() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/AbstractOverrideInEnum.kt"); + } + + @Test + public void testAllFilesPresentInEnum() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/enum"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("classObjectInEnum.kt") + public void testClassObjectInEnum() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/classObjectInEnum.kt"); + } + + @Test + @TestMetadata("classObjectInEnumPrivate.kt") + public void testClassObjectInEnumPrivate() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/classObjectInEnumPrivate.kt"); + } + + @Test + @TestMetadata("commonSupertype.kt") + public void testCommonSupertype() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/commonSupertype.kt"); + } + + @Test + @TestMetadata("compareTwoDifferentEnums.kt") + public void testCompareTwoDifferentEnums() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/compareTwoDifferentEnums.kt"); + } + + @Test + @TestMetadata("ConstructorCallFromOutside.kt") + public void testConstructorCallFromOutside() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/ConstructorCallFromOutside.kt"); + } + + @Test + @TestMetadata("constructorWithDefaultParametersOnly.kt") + public void testConstructorWithDefaultParametersOnly() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/constructorWithDefaultParametersOnly.kt"); + } + + @Test + @TestMetadata("declaringClass.kt") + public void testDeclaringClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/declaringClass.kt"); + } + + @Test + @TestMetadata("dontCreatePackageTypeForEnumEntry_after.kt") + public void testDontCreatePackageTypeForEnumEntry_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/dontCreatePackageTypeForEnumEntry_after.kt"); + } + + @Test + @TestMetadata("dontCreatePackageTypeForEnumEntry_before.kt") + public void testDontCreatePackageTypeForEnumEntry_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/dontCreatePackageTypeForEnumEntry_before.kt"); + } + + @Test + @TestMetadata("emptyConstructor.kt") + public void testEmptyConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/emptyConstructor.kt"); + } + + @Test + @TestMetadata("entryShouldBeOfEnumType.kt") + public void testEntryShouldBeOfEnumType() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/entryShouldBeOfEnumType.kt"); + } + + @Test + @TestMetadata("enumEntryCannotHaveClassObject.kt") + public void testEnumEntryCannotHaveClassObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/enumEntryCannotHaveClassObject.kt"); + } + + @Test + @TestMetadata("enumEntryInAbstractEnum.kt") + public void testEnumEntryInAbstractEnum() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/enumEntryInAbstractEnum.kt"); + } + + @Test + @TestMetadata("enumImplementingTrait.kt") + public void testEnumImplementingTrait() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/enumImplementingTrait.kt"); + } + + @Test + @TestMetadata("enumInheritance.kt") + public void testEnumInheritance() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/enumInheritance.kt"); + } + + @Test + @TestMetadata("enumIsAssignableToBuiltInEnum.kt") + public void testEnumIsAssignableToBuiltInEnum() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/enumIsAssignableToBuiltInEnum.kt"); + } + + @Test + @TestMetadata("enumMissingName.kt") + public void testEnumMissingName() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/enumMissingName.kt"); + } + + @Test + @TestMetadata("enumModifier.kt") + public void testEnumModifier() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/enumModifier.kt"); + } + + @Test + @TestMetadata("enumStarImport.kt") + public void testEnumStarImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/enumStarImport.kt"); + } + + @Test + @TestMetadata("enumSubjectTypeCheck.kt") + public void testEnumSubjectTypeCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/enumSubjectTypeCheck.kt"); + } + + @Test + @TestMetadata("enumWithAnnotationKeyword.kt") + public void testEnumWithAnnotationKeyword() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/enumWithAnnotationKeyword.kt"); + } + + @Test + @TestMetadata("enumWithEmptyName.kt") + public void testEnumWithEmptyName() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/enumWithEmptyName.kt"); + } + + @Test + @TestMetadata("ExplicitConstructorCall.kt") + public void testExplicitConstructorCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/ExplicitConstructorCall.kt"); + } + + @Test + @TestMetadata("extendingEnumDirectly.kt") + public void testExtendingEnumDirectly() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/extendingEnumDirectly.kt"); + } + + @Test + @TestMetadata("extensionNamedAsEnumEntry.kt") + public void testExtensionNamedAsEnumEntry() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/extensionNamedAsEnumEntry.kt"); + } + + @Test + @TestMetadata("ifEnumEntry.kt") + public void testIfEnumEntry() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/ifEnumEntry.kt"); + } + + @Test + @TestMetadata("importEnumFromJava.kt") + public void testImportEnumFromJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/importEnumFromJava.kt"); + } + + @Test + @TestMetadata("incompatibleEnumEntryClasses.kt") + public void testIncompatibleEnumEntryClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/incompatibleEnumEntryClasses.kt"); + } + + @Test + @TestMetadata("incompatibleEnums.kt") + public void testIncompatibleEnums() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/incompatibleEnums.kt"); + } + + @Test + @TestMetadata("incompatibleEnums_1_4.kt") + public void testIncompatibleEnums_1_4() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/incompatibleEnums_1_4.kt"); + } + + @Test + @TestMetadata("inheritFromEnumEntry.kt") + public void testInheritFromEnumEntry() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/inheritFromEnumEntry.kt"); + } + + @Test + @TestMetadata("inheritanceFromEnum.kt") + public void testInheritanceFromEnum() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/inheritanceFromEnum.kt"); + } + + @Test + @TestMetadata("inline.kt") + public void testInline() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/inline.kt"); + } + + @Test + @TestMetadata("InsideEntryConstructorCall.kt") + public void testInsideEntryConstructorCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/InsideEntryConstructorCall.kt"); + } + + @Test + @TestMetadata("InsideSecondaryConstructorCall.kt") + public void testInsideSecondaryConstructorCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/InsideSecondaryConstructorCall.kt"); + } + + @Test + @TestMetadata("interfaceWithEnumKeyword.kt") + public void testInterfaceWithEnumKeyword() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/interfaceWithEnumKeyword.kt"); + } + + @Test + @TestMetadata("isEnumEntry.kt") + public void testIsEnumEntry() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/isEnumEntry.kt"); + } + + @Test + @TestMetadata("javaEnumValueOfMethod.kt") + public void testJavaEnumValueOfMethod() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/javaEnumValueOfMethod.kt"); + } + + @Test + @TestMetadata("javaEnumValuesMethod.kt") + public void testJavaEnumValuesMethod() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/javaEnumValuesMethod.kt"); + } + + @Test + @TestMetadata("javaEnumWithAbstractFun.kt") + public void testJavaEnumWithAbstractFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/javaEnumWithAbstractFun.kt"); + } + + @Test + @TestMetadata("javaEnumWithFuns.kt") + public void testJavaEnumWithFuns() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/javaEnumWithFuns.kt"); + } + + @Test + @TestMetadata("javaEnumWithNameClashing.kt") + public void testJavaEnumWithNameClashing() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/javaEnumWithNameClashing.kt"); + } + + @Test + @TestMetadata("javaEnumWithProperty.kt") + public void testJavaEnumWithProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/javaEnumWithProperty.kt"); + } + + @Test + @TestMetadata("kt2834.kt") + public void testKt2834() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/kt2834.kt"); + } + + @Test + @TestMetadata("kt8972_cloneNotAllowed.kt") + public void testKt8972_cloneNotAllowed() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/kt8972_cloneNotAllowed.kt"); + } + + @Test + @TestMetadata("localEnums.kt") + public void testLocalEnums() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/localEnums.kt"); + } + + @Test + @TestMetadata("modifiersOnEnumEntry.kt") + public void testModifiersOnEnumEntry() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/modifiersOnEnumEntry.kt"); + } + + @Test + @TestMetadata("multipleConstructors.kt") + public void testMultipleConstructors() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/multipleConstructors.kt"); + } + + @Test + @TestMetadata("NonPrivateConstructor.kt") + public void testNonPrivateConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/NonPrivateConstructor.kt"); + } + + @Test + @TestMetadata("openMemberInEnum.kt") + public void testOpenMemberInEnum() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/openMemberInEnum.kt"); + } + + @Test + @TestMetadata("overrideFinalEnumMethods.kt") + public void testOverrideFinalEnumMethods() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/overrideFinalEnumMethods.kt"); + } + + @Test + @TestMetadata("SecondaryConstructorCall.kt") + public void testSecondaryConstructorCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/SecondaryConstructorCall.kt"); + } + + @Test + @TestMetadata("secondaryConstructorWithoutDelegatingToPrimaryOne.kt") + public void testSecondaryConstructorWithoutDelegatingToPrimaryOne() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/secondaryConstructorWithoutDelegatingToPrimaryOne.kt"); + } + + @Test + @TestMetadata("secondaryConstructorWithoutDelegatingToPrimaryOneWithEnabledFeature.kt") + public void testSecondaryConstructorWithoutDelegatingToPrimaryOneWithEnabledFeature() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/secondaryConstructorWithoutDelegatingToPrimaryOneWithEnabledFeature.kt"); + } + + @Test + @TestMetadata("starImportNestedClassAndEntries.kt") + public void testStarImportNestedClassAndEntries() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/starImportNestedClassAndEntries.kt"); + } + + @Test + @TestMetadata("typeCompatibility.kt") + public void testTypeCompatibility() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/typeCompatibility.kt"); + } + + @Test + @TestMetadata("typeParametersInEnum.kt") + public void testTypeParametersInEnum() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/typeParametersInEnum.kt"); + } + + @Test + @TestMetadata("valuesValueOfAndEntriesAccessibility.kt") + public void testValuesValueOfAndEntriesAccessibility() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/valuesValueOfAndEntriesAccessibility.kt"); + } + + @Test + @TestMetadata("wrongUnitializedEnumCompanion.kt") + public void testWrongUnitializedEnumCompanion() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/wrongUnitializedEnumCompanion.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/enum/entries") + @TestDataPath("$PROJECT_ROOT") + public class Entries { + @Test + public void testAllFilesPresentInEntries() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/enum/entries"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("conflictingPropertyEntriesAndReference.kt") + public void testConflictingPropertyEntriesAndReference() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/entries/conflictingPropertyEntriesAndReference.kt"); + } + + @Test + @TestMetadata("entriesPropertyAsExtensionClash.kt") + public void testEntriesPropertyAsExtensionClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/entries/entriesPropertyAsExtensionClash.kt"); + } + + @Test + @TestMetadata("entriesPropertyAsExtensionClashOn.kt") + public void testEntriesPropertyAsExtensionClashOn() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/entries/entriesPropertyAsExtensionClashOn.kt"); + } + + @Test + @TestMetadata("entriesPropertyImportedClash.kt") + public void testEntriesPropertyImportedClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/entries/entriesPropertyImportedClash.kt"); + } + + @Test + @TestMetadata("entriesPropertyImportedClashOn.kt") + public void testEntriesPropertyImportedClashOn() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/entries/entriesPropertyImportedClashOn.kt"); + } + + @Test + @TestMetadata("entriesPropertyInCompanionClash.kt") + public void testEntriesPropertyInCompanionClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/entries/entriesPropertyInCompanionClash.kt"); + } + + @Test + @TestMetadata("entriesPropertyInCompanionClashOn.kt") + public void testEntriesPropertyInCompanionClashOn() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/entries/entriesPropertyInCompanionClashOn.kt"); + } + + @Test + @TestMetadata("entriesPropertyWithJvmStaticClash.kt") + public void testEntriesPropertyWithJvmStaticClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/entries/entriesPropertyWithJvmStaticClash.kt"); + } + + @Test + @TestMetadata("entriesUnsupported.kt") + public void testEntriesUnsupported() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/entries/entriesUnsupported.kt"); + } + + @Test + @TestMetadata("enumEntriesAmbiguity.kt") + public void testEnumEntriesAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/entries/enumEntriesAmbiguity.kt"); + } + + @Test + @TestMetadata("genericEntriesPropertyClash.kt") + public void testGenericEntriesPropertyClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/entries/genericEntriesPropertyClash.kt"); + } + + @Test + @TestMetadata("javaEnumEntriesAmbiguity.kt") + public void testJavaEnumEntriesAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/entries/javaEnumEntriesAmbiguity.kt"); + } + + @Test + @TestMetadata("nameShadowingOfExternallyDefinedEntries.kt") + public void testNameShadowingOfExternallyDefinedEntries() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/entries/nameShadowingOfExternallyDefinedEntries.kt"); + } + + @Test + @TestMetadata("nameShadowingOfExternallyDefinedEntriesOn.kt") + public void testNameShadowingOfExternallyDefinedEntriesOn() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/entries/nameShadowingOfExternallyDefinedEntriesOn.kt"); + } + + @Test + @TestMetadata("redeclarationOfEnumEntriesNameWithIntrinsic.kt") + public void testRedeclarationOfEnumEntriesNameWithIntrinsic() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/entries/redeclarationOfEnumEntriesNameWithIntrinsic.kt"); + } + + @Test + @TestMetadata("redeclarationOfEnumEntriesNameWithIntrinsicOn.kt") + public void testRedeclarationOfEnumEntriesNameWithIntrinsicOn() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/entries/redeclarationOfEnumEntriesNameWithIntrinsicOn.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/enum/inner") + @TestDataPath("$PROJECT_ROOT") + public class Inner { + @Test + public void testAllFilesPresentInInner() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/enum/inner"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("existingClassObject.kt") + public void testExistingClassObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/inner/existingClassObject.kt"); + } + + @Test + @TestMetadata("insideClass.kt") + public void testInsideClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/inner/insideClass.kt"); + } + + @Test + @TestMetadata("insideClassObject.kt") + public void testInsideClassObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/inner/insideClassObject.kt"); + } + + @Test + @TestMetadata("insideEnum.kt") + public void testInsideEnum() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/inner/insideEnum.kt"); + } + + @Test + @TestMetadata("insideEnumEntry_after.kt") + public void testInsideEnumEntry_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/inner/insideEnumEntry_after.kt"); + } + + @Test + @TestMetadata("insideEnumEntry_before.kt") + public void testInsideEnumEntry_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/inner/insideEnumEntry_before.kt"); + } + + @Test + @TestMetadata("insideInnerClassNotAllowed.kt") + public void testInsideInnerClassNotAllowed() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/inner/insideInnerClassNotAllowed.kt"); + } + + @Test + @TestMetadata("insideObject.kt") + public void testInsideObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/inner/insideObject.kt"); + } + + @Test + @TestMetadata("insideTrait.kt") + public void testInsideTrait() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/inner/insideTrait.kt"); + } + + @Test + @TestMetadata("redeclarationInClassObject.kt") + public void testRedeclarationInClassObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/inner/redeclarationInClassObject.kt"); + } + + @Test + @TestMetadata("twoEnums.kt") + public void testTwoEnums() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/inner/twoEnums.kt"); + } + + @Test + @TestMetadata("twoEnumsInClassObjectAndInnerClass.kt") + public void testTwoEnumsInClassObjectAndInnerClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/enum/inner/twoEnumsInClassObjectAndInnerClass.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/evaluate") + @TestDataPath("$PROJECT_ROOT") + public class Evaluate { + @Test + public void testAllFilesPresentInEvaluate() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/evaluate"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("binaryMinusDepOnExpType.kt") + public void testBinaryMinusDepOnExpType() throws Exception { + runTest("compiler/testData/diagnostics/tests/evaluate/binaryMinusDepOnExpType.kt"); + } + + @Test + @TestMetadata("binaryMinusIndepWoExpType.kt") + public void testBinaryMinusIndepWoExpType() throws Exception { + runTest("compiler/testData/diagnostics/tests/evaluate/binaryMinusIndepWoExpType.kt"); + } + + @Test + @TestMetadata("binaryMinusIndependentExpType.kt") + public void testBinaryMinusIndependentExpType() throws Exception { + runTest("compiler/testData/diagnostics/tests/evaluate/binaryMinusIndependentExpType.kt"); + } + + @Test + @TestMetadata("customExtensionOverKotlinExtensionInConst.kt") + public void testCustomExtensionOverKotlinExtensionInConst() throws Exception { + runTest("compiler/testData/diagnostics/tests/evaluate/customExtensionOverKotlinExtensionInConst.kt"); + } + + @Test + @TestMetadata("divisionByZero.kt") + public void testDivisionByZero() throws Exception { + runTest("compiler/testData/diagnostics/tests/evaluate/divisionByZero.kt"); + } + + @Test + @TestMetadata("float.kt") + public void testFloat() throws Exception { + runTest("compiler/testData/diagnostics/tests/evaluate/float.kt"); + } + + @Test + @TestMetadata("floatLiteralOutOfRange.kt") + public void testFloatLiteralOutOfRange() throws Exception { + runTest("compiler/testData/diagnostics/tests/evaluate/floatLiteralOutOfRange.kt"); + } + + @Test + @TestMetadata("infixFunOverBuiltinMemberInConst.kt") + public void testInfixFunOverBuiltinMemberInConst() throws Exception { + runTest("compiler/testData/diagnostics/tests/evaluate/infixFunOverBuiltinMemberInConst.kt"); + } + + @Test + @TestMetadata("intOverflow.kt") + public void testIntOverflow() throws Exception { + runTest("compiler/testData/diagnostics/tests/evaluate/intOverflow.kt"); + } + + @Test + @TestMetadata("intOverflowWithJavaProperties.kt") + public void testIntOverflowWithJavaProperties() throws Exception { + runTest("compiler/testData/diagnostics/tests/evaluate/intOverflowWithJavaProperties.kt"); + } + + @Test + @TestMetadata("integer.kt") + public void testInteger() throws Exception { + runTest("compiler/testData/diagnostics/tests/evaluate/integer.kt"); + } + + @Test + @TestMetadata("logicWithNumber.kt") + public void testLogicWithNumber() throws Exception { + runTest("compiler/testData/diagnostics/tests/evaluate/logicWithNumber.kt"); + } + + @Test + @TestMetadata("longOverflow.kt") + public void testLongOverflow() throws Exception { + runTest("compiler/testData/diagnostics/tests/evaluate/longOverflow.kt"); + } + + @Test + @TestMetadata("noOverflowWithZero.kt") + public void testNoOverflowWithZero() throws Exception { + runTest("compiler/testData/diagnostics/tests/evaluate/noOverflowWithZero.kt"); + } + + @Test + @TestMetadata("numberBinaryOperations.kt") + public void testNumberBinaryOperations() throws Exception { + runTest("compiler/testData/diagnostics/tests/evaluate/numberBinaryOperations.kt"); + } + + @Test + @TestMetadata("numberBinaryOperationsCall.kt") + public void testNumberBinaryOperationsCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/evaluate/numberBinaryOperationsCall.kt"); + } + + @Test + @TestMetadata("numberBinaryOperationsInfixCall.kt") + public void testNumberBinaryOperationsInfixCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/evaluate/numberBinaryOperationsInfixCall.kt"); + } + + @Test + @TestMetadata("otherOverflow.kt") + public void testOtherOverflow() throws Exception { + runTest("compiler/testData/diagnostics/tests/evaluate/otherOverflow.kt"); + } + + @Test + @TestMetadata("parentesized.kt") + public void testParentesized() throws Exception { + runTest("compiler/testData/diagnostics/tests/evaluate/parentesized.kt"); + } + + @Test + @TestMetadata("qualifiedExpressions.kt") + public void testQualifiedExpressions() throws Exception { + runTest("compiler/testData/diagnostics/tests/evaluate/qualifiedExpressions.kt"); + } + + @Test + @TestMetadata("unaryMinusDepOnExpType.kt") + public void testUnaryMinusDepOnExpType() throws Exception { + runTest("compiler/testData/diagnostics/tests/evaluate/unaryMinusDepOnExpType.kt"); + } + + @Test + @TestMetadata("unaryMinusIndepWoExpType.kt") + public void testUnaryMinusIndepWoExpType() throws Exception { + runTest("compiler/testData/diagnostics/tests/evaluate/unaryMinusIndepWoExpType.kt"); + } + + @Test + @TestMetadata("unaryMinusIndependentExpType.kt") + public void testUnaryMinusIndependentExpType() throws Exception { + runTest("compiler/testData/diagnostics/tests/evaluate/unaryMinusIndependentExpType.kt"); + } + + @Test + @TestMetadata("wrongLongSuffix.kt") + public void testWrongLongSuffix() throws Exception { + runTest("compiler/testData/diagnostics/tests/evaluate/wrongLongSuffix.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/evaluate/inlineClasses") + @TestDataPath("$PROJECT_ROOT") + public class InlineClasses { + @Test + public void testAllFilesPresentInInlineClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/evaluate/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("constructorOfUnsignedType.kt") + public void testConstructorOfUnsignedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/evaluate/inlineClasses/constructorOfUnsignedType.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/exceptions") + @TestDataPath("$PROJECT_ROOT") + public class Exceptions { + @Test + public void testAllFilesPresentInExceptions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/exceptions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("expectedSomeTypesOnBranchForWhenExpressionOfErroneousType.kt") + public void testExpectedSomeTypesOnBranchForWhenExpressionOfErroneousType() throws Exception { + runTest("compiler/testData/diagnostics/tests/exceptions/expectedSomeTypesOnBranchForWhenExpressionOfErroneousType.kt"); + } + + @Test + @TestMetadata("kt24158.kt") + public void testKt24158() throws Exception { + runTest("compiler/testData/diagnostics/tests/exceptions/kt24158.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection") + @TestDataPath("$PROJECT_ROOT") + public class ExplicitDefinitelyNotNullableViaIntersection { + @Test + public void testAllFilesPresentInExplicitDefinitelyNotNullableViaIntersection() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("approximation.kt") + public void testApproximation() throws Exception { + runTest("compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/approximation.kt"); + } + + @Test + @TestMetadata("bareTypes.kt") + public void testBareTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/bareTypes.kt"); + } + + @Test + @TestMetadata("disabledFeature.kt") + public void testDisabledFeature() throws Exception { + runTest("compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/disabledFeature.kt"); + } + + @Test + @TestMetadata("inference.kt") + public void testInference() throws Exception { + runTest("compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/inference.kt"); + } + + @Test + @TestMetadata("isAsOperators.kt") + public void testIsAsOperators() throws Exception { + runTest("compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/isAsOperators.kt"); + } + + @Test + @TestMetadata("isAsOperatorsEnabled.kt") + public void testIsAsOperatorsEnabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/isAsOperatorsEnabled.kt"); + } + + @Test + @TestMetadata("notApplicable.kt") + public void testNotApplicable() throws Exception { + runTest("compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/notApplicable.kt"); + } + + @Test + @TestMetadata("overrides.kt") + public void testOverrides() throws Exception { + runTest("compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/overrides.kt"); + } + + @Test + @TestMetadata("overridesJavaAnnotated.kt") + public void testOverridesJavaAnnotated() throws Exception { + runTest("compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/overridesJavaAnnotated.kt"); + } + + @Test + @TestMetadata("recursiveBounds.kt") + public void testRecursiveBounds() throws Exception { + runTest("compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/recursiveBounds.kt"); + } + + @Test + @TestMetadata("reifiedArguments.kt") + public void testReifiedArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/reifiedArguments.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/explicitDefinitelyNotNullableViaIntersection/simple.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/exposed") + @TestDataPath("$PROJECT_ROOT") + public class Exposed { + @Test + public void testAllFilesPresentInExposed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/exposed"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("delegate.kt") + public void testDelegate() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/delegate.kt"); + } + + @Test + @TestMetadata("exceptionOnFakeInvisible.kt") + public void testExceptionOnFakeInvisible() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/exceptionOnFakeInvisible.kt"); + } + + @Test + @TestMetadata("functional.kt") + public void testFunctional() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/functional.kt"); + } + + @Test + @TestMetadata("implements.kt") + public void testImplements() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/implements.kt"); + } + + @Test + @TestMetadata("inaccessibleType.kt") + public void testInaccessibleType() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/inaccessibleType.kt"); + } + + @Test + @TestMetadata("internal.kt") + public void testInternal() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/internal.kt"); + } + + @Test + @TestMetadata("internalAndProtected.kt") + public void testInternalAndProtected() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/internalAndProtected.kt"); + } + + @Test + @TestMetadata("internalFromLocal.kt") + public void testInternalFromLocal() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/internalFromLocal.kt"); + } + + @Test + @TestMetadata("local.kt") + public void testLocal() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/local.kt"); + } + + @Test + @TestMetadata("localFromInternal.kt") + public void testLocalFromInternal() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/localFromInternal.kt"); + } + + @Test + @TestMetadata("localFromPrivate.kt") + public void testLocalFromPrivate() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/localFromPrivate.kt"); + } + + @Test + @TestMetadata("localInFunReturnType.kt") + public void testLocalInFunReturnType() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/localInFunReturnType.kt"); + } + + @Test + @TestMetadata("localInMemberType.kt") + public void testLocalInMemberType() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/localInMemberType.kt"); + } + + @Test + @TestMetadata("localInPropertyType.kt") + public void testLocalInPropertyType() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/localInPropertyType.kt"); + } + + @Test + @TestMetadata("nested.kt") + public void testNested() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/nested.kt"); + } + + @Test + @TestMetadata("object.kt") + public void testObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/object.kt"); + } + + @Test + @TestMetadata("packagePrivate.kt") + public void testPackagePrivate() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/packagePrivate.kt"); + } + + @Test + @TestMetadata("privateFromLocal.kt") + public void testPrivateFromLocal() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/privateFromLocal.kt"); + } + + @Test + @TestMetadata("privateInFile.kt") + public void testPrivateInFile() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/privateInFile.kt"); + } + + @Test + @TestMetadata("privateInFileDisabled.kt") + public void testPrivateInFileDisabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/privateInFileDisabled.kt"); + } + + @Test + @TestMetadata("privatePropertyInPrivateConstructor.kt") + public void testPrivatePropertyInPrivateConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/privatePropertyInPrivateConstructor.kt"); + } + + @Test + @TestMetadata("propertyInConstructorOfPrivateClass.kt") + public void testPropertyInConstructorOfPrivateClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/propertyInConstructorOfPrivateClass.kt"); + } + + @Test + @TestMetadata("propertyInPrivateConstructor.kt") + public void testPropertyInPrivateConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/propertyInPrivateConstructor.kt"); + } + + @Test + @TestMetadata("propertyInPrivateConstructorError.kt") + public void testPropertyInPrivateConstructorError() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/propertyInPrivateConstructorError.kt"); + } + + @Test + @TestMetadata("propertyInSimpleConstructor.kt") + public void testPropertyInSimpleConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/propertyInSimpleConstructor.kt"); + } + + @Test + @TestMetadata("protected.kt") + public void testProtected() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/protected.kt"); + } + + @Test + @TestMetadata("protectedInProtected.kt") + public void testProtectedInProtected() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/protectedInProtected.kt"); + } + + @Test + @TestMetadata("protectedJava.kt") + public void testProtectedJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/protectedJava.kt"); + } + + @Test + @TestMetadata("protectedSameWay.kt") + public void testProtectedSameWay() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/protectedSameWay.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/simple.kt"); + } + + @Test + @TestMetadata("typeArgs.kt") + public void testTypeArgs() throws Exception { + runTest("compiler/testData/diagnostics/tests/exposed/typeArgs.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/extensions") + @TestDataPath("$PROJECT_ROOT") + public class Extensions { + @Test + public void testAllFilesPresentInExtensions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/extensions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("classObject.kt") + public void testClassObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/classObject.kt"); + } + + @Test + @TestMetadata("ExtensionFunctions.kt") + public void testExtensionFunctions() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/ExtensionFunctions.kt"); + } + + @Test + @TestMetadata("extensionMemberInClassObject.kt") + public void testExtensionMemberInClassObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/extensionMemberInClassObject.kt"); + } + + @Test + @TestMetadata("extensionPropertyVsParameter.kt") + public void testExtensionPropertyVsParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/extensionPropertyVsParameter.kt"); + } + + @Test + @TestMetadata("ExtensionsCalledOnSuper.kt") + public void testExtensionsCalledOnSuper() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/ExtensionsCalledOnSuper.kt"); + } + + @Test + @TestMetadata("GenericIterator.kt") + public void testGenericIterator() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/GenericIterator.kt"); + } + + @Test + @TestMetadata("GenericIterator2.kt") + public void testGenericIterator2() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/GenericIterator2.kt"); + } + + @Test + @TestMetadata("kt1875.kt") + public void testKt1875() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/kt1875.kt"); + } + + @Test + @TestMetadata("kt2317.kt") + public void testKt2317() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/kt2317.kt"); + } + + @Test + @TestMetadata("kt3470.kt") + public void testKt3470() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/kt3470.kt"); + } + + @Test + @TestMetadata("kt3563.kt") + public void testKt3563() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/kt3563.kt"); + } + + @Test + @TestMetadata("kt819ExtensionProperties.kt") + public void testKt819ExtensionProperties() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/kt819ExtensionProperties.kt"); + } + + @Test + @TestMetadata("noClassObjectsInJava.kt") + public void testNoClassObjectsInJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/noClassObjectsInJava.kt"); + } + + @Test + @TestMetadata("object.kt") + public void testObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/object.kt"); + } + + @Test + @TestMetadata("throwOutCandidatesByReceiver.kt") + public void testThrowOutCandidatesByReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver.kt"); + } + + @Test + @TestMetadata("throwOutCandidatesByReceiver2.kt") + public void testThrowOutCandidatesByReceiver2() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver2.kt"); + } + + @Test + @TestMetadata("variableInvoke.kt") + public void testVariableInvoke() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/variableInvoke.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/extensions/contextReceivers") + @TestDataPath("$PROJECT_ROOT") + public class ContextReceivers { + @Test + public void testAllFilesPresentInContextReceivers() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/extensions/contextReceivers"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("ambiguityInGroup.kt") + public void testAmbiguityInGroup() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/ambiguityInGroup.kt"); + } + + @Test + @TestMetadata("conflicting.kt") + public void testConflicting() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/conflicting.kt"); + } + + @Test + @TestMetadata("conflictingWithDifferentOrder.kt") + public void testConflictingWithDifferentOrder() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/conflictingWithDifferentOrder.kt"); + } + + @Test + @TestMetadata("contextKeywordWithElvis.kt") + public void testContextKeywordWithElvis() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/contextKeywordWithElvis.kt"); + } + + @Test + @TestMetadata("contextReceiverTypeParamsUsage.kt") + public void testContextReceiverTypeParamsUsage() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/contextReceiverTypeParamsUsage.kt"); + } + + @Test + @TestMetadata("contextReceiverTypeParamsUsageError.kt") + public void testContextReceiverTypeParamsUsageError() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/contextReceiverTypeParamsUsageError.kt"); + } + + @Test + @TestMetadata("contextualFunctionalTypeConversion.kt") + public void testContextualFunctionalTypeConversion() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/contextualFunctionalTypeConversion.kt"); + } + + @Test + @TestMetadata("functionalType.kt") + public void testFunctionalType() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/functionalType.kt"); + } + + @Test + @TestMetadata("genericOuterClass.kt") + public void testGenericOuterClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/genericOuterClass.kt"); + } + + @Test + @TestMetadata("insideDeclaration.kt") + public void testInsideDeclaration() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/insideDeclaration.kt"); + } + + @Test + @TestMetadata("labelFromFunctionName.kt") + public void testLabelFromFunctionName() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/labelFromFunctionName.kt"); + } + + @Test + @TestMetadata("labelsFromClassNameForbidden.kt") + public void testLabelsFromClassNameForbidden() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/labelsFromClassNameForbidden.kt"); + } + + @Test + @TestMetadata("lazy.kt") + public void testLazy() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/lazy.kt"); + } + + @Test + @TestMetadata("manyReceivers.kt") + public void testManyReceivers() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/manyReceivers.kt"); + } + + @Test + @TestMetadata("noBackingField.kt") + public void testNoBackingField() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/noBackingField.kt"); + } + + @Test + @TestMetadata("noContextReceiversOnValueClasses.kt") + public void testNoContextReceiversOnValueClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/noContextReceiversOnValueClasses.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithUniversal()); + } + + @Test + @TestMetadata("noExplicitReceiver.kt") + public void testNoExplicitReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/noExplicitReceiver.kt"); + } + + @Test + @TestMetadata("noLabelsByClassName.kt") + public void testNoLabelsByClassName() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/noLabelsByClassName.kt"); + } + + @Test + @TestMetadata("nonConflicting.kt") + public void testNonConflicting() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/nonConflicting.kt"); + } + + @Test + @TestMetadata("outerClass.kt") + public void testOuterClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/outerClass.kt"); + } + + @Test + @TestMetadata("overloadPriority.kt") + public void testOverloadPriority() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/overloadPriority.kt"); + } + + @Test + @TestMetadata("overloading.kt") + public void testOverloading() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/overloading.kt"); + } + + @Test + @TestMetadata("parameterizedContextualLambda.kt") + public void testParameterizedContextualLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/parameterizedContextualLambda.kt"); + } + + @Test + @TestMetadata("plusMatrix.kt") + public void testPlusMatrix() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/plusMatrix.kt"); + } + + @Test + @TestMetadata("subtypingBetweenContextReceivers.kt") + public void testSubtypingBetweenContextReceivers() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/subtypingBetweenContextReceivers.kt"); + } + + @Test + @TestMetadata("superWithContext.kt") + public void testSuperWithContext() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/superWithContext.kt"); + } + + @Test + @TestMetadata("syntaxError.kt") + public void testSyntaxError() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/syntaxError.kt"); + } + + @Test + @TestMetadata("thisIdentifierInfo.kt") + public void testThisIdentifierInfo() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/thisIdentifierInfo.kt"); + } + + @Test + @TestMetadata("thisWithCustomLabel.kt") + public void testThisWithCustomLabel() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/thisWithCustomLabel.kt"); + } + + @Test + @TestMetadata("thisWithReceiverLabelsClasses.kt") + public void testThisWithReceiverLabelsClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/thisWithReceiverLabelsClasses.kt"); + } + + @Test + @TestMetadata("thisWithReceiverLabelsFunctions.kt") + public void testThisWithReceiverLabelsFunctions() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/thisWithReceiverLabelsFunctions.kt"); + } + + @Test + @TestMetadata("thisWithReceiverLabelsProperties.kt") + public void testThisWithReceiverLabelsProperties() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/thisWithReceiverLabelsProperties.kt"); + } + + @Test + @TestMetadata("twoReceiverCandidatesError.kt") + public void testTwoReceiverCandidatesError() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/twoReceiverCandidatesError.kt"); + } + + @Test + @TestMetadata("typeParameterAsContextReceiver.kt") + public void testTypeParameterAsContextReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/typeParameterAsContextReceiver.kt"); + } + + @Test + @TestMetadata("typeParameterized.kt") + public void testTypeParameterized() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/typeParameterized.kt"); + } + + @Test + @TestMetadata("typeParameterizedList.kt") + public void testTypeParameterizedList() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/typeParameterizedList.kt"); + } + + @Test + @TestMetadata("unsupported.kt") + public void testUnsupported() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/unsupported.kt"); + } + + @Test + @TestMetadata("withExplicitReceiver.kt") + public void testWithExplicitReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/withExplicitReceiver.kt"); + } + + @Test + @TestMetadata("withExplicitReceiverError.kt") + public void testWithExplicitReceiverError() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/withExplicitReceiverError.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/extensions/contextReceivers/fromKEEP") + @TestDataPath("$PROJECT_ROOT") + public class FromKEEP { + @Test + public void testAllFilesPresentInFromKEEP() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/extensions/contextReceivers/fromKEEP"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("autoCloseScope.kt") + public void testAutoCloseScope() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/fromKEEP/autoCloseScope.kt"); + } + + @Test + @TestMetadata("canvas.kt") + public void testCanvas() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/fromKEEP/canvas.kt"); + } + + @Test + @TestMetadata("clickHandler.kt") + public void testClickHandler() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/fromKEEP/clickHandler.kt"); + } + + @Test + @TestMetadata("compareTo.kt") + public void testCompareTo() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/fromKEEP/compareTo.kt"); + } + + @Test + @TestMetadata("decimateEveryEvenThird.kt") + public void testDecimateEveryEvenThird() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/fromKEEP/decimateEveryEvenThird.kt"); + } + + @Test + @TestMetadata("dp.kt") + public void testDp() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/fromKEEP/dp.kt"); + } + + @Test + @TestMetadata("functionalType.kt") + public void testFunctionalType() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/fromKEEP/functionalType.kt"); + } + + @Test + @TestMetadata("iterableClass.kt") + public void testIterableClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/fromKEEP/iterableClass.kt"); + } + + @Test + @TestMetadata("json.kt") + public void testJson() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/fromKEEP/json.kt"); + } + + @Test + @TestMetadata("loggingContext.kt") + public void testLoggingContext() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/fromKEEP/loggingContext.kt"); + } + + @Test + @TestMetadata("monoidSum.kt") + public void testMonoidSum() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/fromKEEP/monoidSum.kt"); + } + + @Test + @TestMetadata("transaction.kt") + public void testTransaction() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/fromKEEP/transaction.kt"); + } + + @Test + @TestMetadata("userStorage.kt") + public void testUserStorage() throws Exception { + runTest("compiler/testData/diagnostics/tests/extensions/contextReceivers/fromKEEP/userStorage.kt"); + } + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/external") + @TestDataPath("$PROJECT_ROOT") + public class External { + @Test + public void testAllFilesPresentInExternal() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/external"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("noExternalModifierInheritance.kt") + public void testNoExternalModifierInheritance() throws Exception { + runTest("compiler/testData/diagnostics/tests/external/noExternalModifierInheritance.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/fieldRename") + @TestDataPath("$PROJECT_ROOT") + public class FieldRename { + @Test + public void testAllFilesPresentInFieldRename() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/fieldRename"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("derivedClassPropertyShadowsBaseClassField.kt") + public void testDerivedClassPropertyShadowsBaseClassField() throws Exception { + runTest("compiler/testData/diagnostics/tests/fieldRename/derivedClassPropertyShadowsBaseClassField.kt"); + } + + @Test + @TestMetadata("derivedClassPropertyShadowsBaseClassField13.kt") + public void testDerivedClassPropertyShadowsBaseClassField13() throws Exception { + runTest("compiler/testData/diagnostics/tests/fieldRename/derivedClassPropertyShadowsBaseClassField13.kt"); + } + + @Test + @TestMetadata("javaFieldKotlinPropertyJavaFieldInPackagePrivate.kt") + public void testJavaFieldKotlinPropertyJavaFieldInPackagePrivate() throws Exception { + runTest("compiler/testData/diagnostics/tests/fieldRename/javaFieldKotlinPropertyJavaFieldInPackagePrivate.kt"); + } + + @Test + @TestMetadata("javaFieldKotlinPropertyJavaPackagePrivateField.kt") + public void testJavaFieldKotlinPropertyJavaPackagePrivateField() throws Exception { + runTest("compiler/testData/diagnostics/tests/fieldRename/javaFieldKotlinPropertyJavaPackagePrivateField.kt"); + } + + @Test + @TestMetadata("javaProtectedFieldAndKotlinInvisiblePropertyReference.kt") + public void testJavaProtectedFieldAndKotlinInvisiblePropertyReference() throws Exception { + runTest("compiler/testData/diagnostics/tests/fieldRename/javaProtectedFieldAndKotlinInvisiblePropertyReference.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/funInterface") + @TestDataPath("$PROJECT_ROOT") + public class FunInterface { + @Test + public void testAllFilesPresentInFunInterface() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/funInterface"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("basicFunInterface.kt") + public void testBasicFunInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/funInterface/basicFunInterface.kt"); + } + + @Test + @TestMetadata("basicFunInterfaceConversion.kt") + public void testBasicFunInterfaceConversion() throws Exception { + runTest("compiler/testData/diagnostics/tests/funInterface/basicFunInterfaceConversion.kt"); + } + + @Test + @TestMetadata("basicFunInterfaceDisabled.kt") + public void testBasicFunInterfaceDisabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/funInterface/basicFunInterfaceDisabled.kt"); + } + + @Test + @TestMetadata("funInterfaceConstructorReferences_after.kt") + public void testFunInterfaceConstructorReferences_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/funInterface/funInterfaceConstructorReferences_after.kt"); + } + + @Test + @TestMetadata("funInterfaceConstructorReferences_before.kt") + public void testFunInterfaceConstructorReferences_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/funInterface/funInterfaceConstructorReferences_before.kt"); + } + + @Test + @TestMetadata("funInterfaceConversionOnReceiver.kt") + public void testFunInterfaceConversionOnReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/funInterface/funInterfaceConversionOnReceiver.kt"); + } + + @Test + @TestMetadata("funInterfaceDeclarationCheck.kt") + public void testFunInterfaceDeclarationCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/funInterface/funInterfaceDeclarationCheck.kt"); + } + + @Test + @TestMetadata("funInterfaceSyntheticConstructors.kt") + public void testFunInterfaceSyntheticConstructors() throws Exception { + runTest("compiler/testData/diagnostics/tests/funInterface/funInterfaceSyntheticConstructors.kt"); + } + + @Test + @TestMetadata("funIsNotInheritedFromBaseInterface.kt") + public void testFunIsNotInheritedFromBaseInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/funInterface/funIsNotInheritedFromBaseInterface.kt"); + } + + @Test + @TestMetadata("functionDelegateClashOnJvm.kt") + public void testFunctionDelegateClashOnJvm() throws Exception { + runTest("compiler/testData/diagnostics/tests/funInterface/functionDelegateClashOnJvm.kt"); + } + + @Test + @TestMetadata("genericSubstitutionForFunInterface.kt") + public void testGenericSubstitutionForFunInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/funInterface/genericSubstitutionForFunInterface.kt"); + } + + @Test + @TestMetadata("noCompatibilityResolveForFunInterfaces.kt") + public void testNoCompatibilityResolveForFunInterfaces() throws Exception { + runTest("compiler/testData/diagnostics/tests/funInterface/noCompatibilityResolveForFunInterfaces.kt"); + } + + @Test + @TestMetadata("resolveFunInterfaceWithoutMainMethod.kt") + public void testResolveFunInterfaceWithoutMainMethod() throws Exception { + runTest("compiler/testData/diagnostics/tests/funInterface/resolveFunInterfaceWithoutMainMethod.kt"); + } + + @Test + @TestMetadata("severalConversionsForFunInterface.kt") + public void testSeveralConversionsForFunInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/funInterface/severalConversionsForFunInterface.kt"); + } + + @Test + @TestMetadata("suspendFunInterfaceConversion.kt") + public void testSuspendFunInterfaceConversion() throws Exception { + runTest("compiler/testData/diagnostics/tests/funInterface/suspendFunInterfaceConversion.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/functionAsExpression") + @TestDataPath("$PROJECT_ROOT") + public class FunctionAsExpression { + @Test + public void testAllFilesPresentInFunctionAsExpression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/functionAsExpression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("AutoLabels.kt") + public void testAutoLabels() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionAsExpression/AutoLabels.kt"); + } + + @Test + @TestMetadata("Common.kt") + public void testCommon() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionAsExpression/Common.kt"); + } + + @Test + @TestMetadata("DifficultInferenceForParameter.kt") + public void testDifficultInferenceForParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionAsExpression/DifficultInferenceForParameter.kt"); + } + + @Test + @TestMetadata("ForbiddenNonLocalReturn.kt") + public void testForbiddenNonLocalReturn() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionAsExpression/ForbiddenNonLocalReturn.kt"); + } + + @Test + @TestMetadata("FunctionType.kt") + public void testFunctionType() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionAsExpression/FunctionType.kt"); + } + + @Test + @TestMetadata("InferenceParametersTypes.kt") + public void testInferenceParametersTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionAsExpression/InferenceParametersTypes.kt"); + } + + @Test + @TestMetadata("MissingParameterTypes.kt") + public void testMissingParameterTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionAsExpression/MissingParameterTypes.kt"); + } + + @Test + @TestMetadata("NameDeprecation.kt") + public void testNameDeprecation() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionAsExpression/NameDeprecation.kt"); + } + + @Test + @TestMetadata("NoOverloadError.kt") + public void testNoOverloadError() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionAsExpression/NoOverloadError.kt"); + } + + @Test + @TestMetadata("Parameters.kt") + public void testParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionAsExpression/Parameters.kt"); + } + + @Test + @TestMetadata("ReceiverByExpectedType.kt") + public void testReceiverByExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionAsExpression/ReceiverByExpectedType.kt"); + } + + @Test + @TestMetadata("ReturnAndLabels.kt") + public void testReturnAndLabels() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionAsExpression/ReturnAndLabels.kt"); + } + + @Test + @TestMetadata("ReturnTypeCheck.kt") + public void testReturnTypeCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionAsExpression/ReturnTypeCheck.kt"); + } + + @Test + @TestMetadata("ScopeCheck.kt") + public void testScopeCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionAsExpression/ScopeCheck.kt"); + } + + @Test + @TestMetadata("WithGenericParameters.kt") + public void testWithGenericParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionAsExpression/WithGenericParameters.kt"); + } + + @Test + @TestMetadata("WithOuterGeneric.kt") + public void testWithOuterGeneric() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionAsExpression/WithOuterGeneric.kt"); + } + + @Test + @TestMetadata("WithoutBody.kt") + public void testWithoutBody() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionAsExpression/WithoutBody.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/functionLiterals") + @TestDataPath("$PROJECT_ROOT") + public class FunctionLiterals { + @Test + public void testAllFilesPresentInFunctionLiterals() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/functionLiterals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("assignmentOperationInLambda.kt") + public void testAssignmentOperationInLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/assignmentOperationInLambda.kt"); + } + + @Test + @TestMetadata("assignmentOperationInLambdaWithExpectedType.kt") + public void testAssignmentOperationInLambdaWithExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/assignmentOperationInLambdaWithExpectedType.kt"); + } + + @Test + @TestMetadata("DeprecatedSyntax.kt") + public void testDeprecatedSyntax() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/DeprecatedSyntax.kt"); + } + + @Test + @TestMetadata("ExpectedParameterTypeMismatchVariance.kt") + public void testExpectedParameterTypeMismatchVariance() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/ExpectedParameterTypeMismatchVariance.kt"); + } + + @Test + @TestMetadata("ExpectedParametersTypesMismatch.kt") + public void testExpectedParametersTypesMismatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/ExpectedParametersTypesMismatch.kt"); + } + + @Test + @TestMetadata("functionExpressionAsLastExpressionInBlock.kt") + public void testFunctionExpressionAsLastExpressionInBlock() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/functionExpressionAsLastExpressionInBlock.kt"); + } + + @Test + @TestMetadata("functionLIteralInBlockInIf.kt") + public void testFunctionLIteralInBlockInIf() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/functionLIteralInBlockInIf.kt"); + } + + @Test + @TestMetadata("functionLiteralAsArgumentForFunction.kt") + public void testFunctionLiteralAsArgumentForFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/functionLiteralAsArgumentForFunction.kt"); + } + + @Test + @TestMetadata("functionLiteralInIf.kt") + public void testFunctionLiteralInIf() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/functionLiteralInIf.kt"); + } + + @Test + @TestMetadata("functionLiteralWithoutArgumentList.kt") + public void testFunctionLiteralWithoutArgumentList() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/functionLiteralWithoutArgumentList.kt"); + } + + @Test + @TestMetadata("genericFunctionalTypeOnRHSOfPlusAssign.kt") + public void testGenericFunctionalTypeOnRHSOfPlusAssign() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/genericFunctionalTypeOnRHSOfPlusAssign.kt"); + } + + @Test + @TestMetadata("higherOrderCallMissingParameters.kt") + public void testHigherOrderCallMissingParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/higherOrderCallMissingParameters.kt"); + } + + @Test + @TestMetadata("kt11733.kt") + public void testKt11733() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/kt11733.kt"); + } + + @Test + @TestMetadata("kt11733_1.kt") + public void testKt11733_1() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/kt11733_1.kt"); + } + + @Test + @TestMetadata("kt16016.kt") + public void testKt16016() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/kt16016.kt"); + } + + @Test + @TestMetadata("kt2906.kt") + public void testKt2906() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/kt2906.kt"); + } + + @Test + @TestMetadata("kt3343.kt") + public void testKt3343() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/kt3343.kt"); + } + + @Test + @TestMetadata("kt4529.kt") + public void testKt4529() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/kt4529.kt"); + } + + @Test + @TestMetadata("kt47493.kt") + public void testKt47493() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/kt47493.kt"); + } + + @Test + @TestMetadata("kt51317.kt") + public void testKt51317() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/kt51317.kt"); + } + + @Test + @TestMetadata("kt56138.kt") + public void testKt56138() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/kt56138.kt"); + } + + @Test + @TestMetadata("kt6541_extensionForExtensionFunction.kt") + public void testKt6541_extensionForExtensionFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/kt6541_extensionForExtensionFunction.kt"); + } + + @Test + @TestMetadata("kt6869.kt") + public void testKt6869() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/kt6869.kt"); + } + + @Test + @TestMetadata("kt7383_starProjectedFunction.kt") + public void testKt7383_starProjectedFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/kt7383_starProjectedFunction.kt"); + } + + @Test + @TestMetadata("LabeledFunctionLiterals.kt") + public void testLabeledFunctionLiterals() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/LabeledFunctionLiterals.kt"); + } + + @Test + @TestMetadata("lambdaInLambda2.kt") + public void testLambdaInLambda2() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/lambdaInLambda2.kt"); + } + + @Test + @TestMetadata("missedTypeMismatch.kt") + public void testMissedTypeMismatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/missedTypeMismatch.kt"); + } + + @Test + @TestMetadata("prematurelyAnalyzingLambdaWhileFixingTypeVariableForAnotherArgument.kt") + public void testPrematurelyAnalyzingLambdaWhileFixingTypeVariableForAnotherArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/prematurelyAnalyzingLambdaWhileFixingTypeVariableForAnotherArgument.kt"); + } + + @Test + @TestMetadata("returnNull.kt") + public void testReturnNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/returnNull.kt"); + } + + @Test + @TestMetadata("returnNullWithReturn.kt") + public void testReturnNullWithReturn() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/returnNullWithReturn.kt"); + } + + @Test + @TestMetadata("underscopeParameters.kt") + public void testUnderscopeParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/underscopeParameters.kt"); + } + + @Test + @TestMetadata("unusedLiteral.kt") + public void testUnusedLiteral() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/unusedLiteral.kt"); + } + + @Test + @TestMetadata("unusedLiteralInsideUnitLiteral.kt") + public void testUnusedLiteralInsideUnitLiteral() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/unusedLiteralInsideUnitLiteral.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas") + @TestDataPath("$PROJECT_ROOT") + public class DestructuringInLambdas { + @Test + public void testAllFilesPresentInDestructuringInLambdas() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("complexInference.kt") + public void testComplexInference() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/complexInference.kt"); + } + + @Test + @TestMetadata("extensionComponents.kt") + public void testExtensionComponents() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/extensionComponents.kt"); + } + + @Test + @TestMetadata("inferredFunctionalType.kt") + public void testInferredFunctionalType() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/inferredFunctionalType.kt"); + } + + @Test + @TestMetadata("modifiers.kt") + public void testModifiers() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/modifiers.kt"); + } + + @Test + @TestMetadata("noExpectedType.kt") + public void testNoExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/noExpectedType.kt"); + } + + @Test + @TestMetadata("redeclaration.kt") + public void testRedeclaration() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/redeclaration.kt"); + } + + @Test + @TestMetadata("shadowing.kt") + public void testShadowing() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/shadowing.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/simple.kt"); + } + + @Test + @TestMetadata("underscore.kt") + public void testUnderscore() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/underscore.kt"); + } + + @Test + @TestMetadata("unusedParameters.kt") + public void testUnusedParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/unusedParameters.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/functionLiterals/return") + @TestDataPath("$PROJECT_ROOT") + public class Return { + @Test + public void testAllFilesPresentInReturn() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/functionLiterals/return"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("AutoLabels.kt") + public void testAutoLabels() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/AutoLabels.kt"); + } + + @Test + @TestMetadata("AutoLabelsNonLocal.kt") + public void testAutoLabelsNonLocal() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/AutoLabelsNonLocal.kt"); + } + + @Test + @TestMetadata("ForbiddenNonLocalReturnNoType.kt") + public void testForbiddenNonLocalReturnNoType() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/ForbiddenNonLocalReturnNoType.kt"); + } + + @Test + @TestMetadata("IfInReturnedExpression.kt") + public void testIfInReturnedExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/IfInReturnedExpression.kt"); + } + + @Test + @TestMetadata("IfWithoutElse.kt") + public void testIfWithoutElse() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/IfWithoutElse.kt"); + } + + @Test + @TestMetadata("IfWithoutElseWithExplicitType.kt") + public void testIfWithoutElseWithExplicitType() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/IfWithoutElseWithExplicitType.kt"); + } + + @Test + @TestMetadata("LambdaWithParameter.kt") + public void testLambdaWithParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LambdaWithParameter.kt"); + } + + @Test + @TestMetadata("LocalAndNonLocalReturnInLambda.kt") + public void testLocalAndNonLocalReturnInLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalAndNonLocalReturnInLambda.kt"); + } + + @Test + @TestMetadata("LocalReturnExplicitLabelNoParens.kt") + public void testLocalReturnExplicitLabelNoParens() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnExplicitLabelNoParens.kt"); + } + + @Test + @TestMetadata("LocalReturnExplicitLabelParens.kt") + public void testLocalReturnExplicitLabelParens() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnExplicitLabelParens.kt"); + } + + @Test + @TestMetadata("LocalReturnHasTypeNothing.kt") + public void testLocalReturnHasTypeNothing() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnHasTypeNothing.kt"); + } + + @Test + @TestMetadata("LocalReturnInNestedFunction.kt") + public void testLocalReturnInNestedFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnInNestedFunction.kt"); + } + + @Test + @TestMetadata("LocalReturnInNestedLambda.kt") + public void testLocalReturnInNestedLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnInNestedLambda.kt"); + } + + @Test + @TestMetadata("LocalReturnNoCoercionToUnit.kt") + public void testLocalReturnNoCoercionToUnit() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnNoCoercionToUnit.kt"); + } + + @Test + @TestMetadata("LocalReturnNull.kt") + public void testLocalReturnNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnNull.kt"); + } + + @Test + @TestMetadata("LocalReturnSecondUnit.kt") + public void testLocalReturnSecondUnit() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnSecondUnit.kt"); + } + + @Test + @TestMetadata("LocalReturnUnit.kt") + public void testLocalReturnUnit() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnUnit.kt"); + } + + @Test + @TestMetadata("LocalReturnUnitAndDontCareType.kt") + public void testLocalReturnUnitAndDontCareType() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnUnitAndDontCareType.kt"); + } + + @Test + @TestMetadata("LocalReturnUnitWithBodyExpression.kt") + public void testLocalReturnUnitWithBodyExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnUnitWithBodyExpression.kt"); + } + + @Test + @TestMetadata("LocalReturnWithExpectedType.kt") + public void testLocalReturnWithExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnWithExpectedType.kt"); + } + + @Test + @TestMetadata("LocalReturnWithExplicitUnit.kt") + public void testLocalReturnWithExplicitUnit() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnWithExplicitUnit.kt"); + } + + @Test + @TestMetadata("LocalReturnsWithExplicitReturnType.kt") + public void testLocalReturnsWithExplicitReturnType() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnsWithExplicitReturnType.kt"); + } + + @Test + @TestMetadata("MixedReturnsFromLambda.kt") + public void testMixedReturnsFromLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/MixedReturnsFromLambda.kt"); + } + + @Test + @TestMetadata("NoCommonSystem.kt") + public void testNoCommonSystem() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/NoCommonSystem.kt"); + } + + @Test + @TestMetadata("SmartCast.kt") + public void testSmartCast() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/SmartCast.kt"); + } + + @Test + @TestMetadata("SmartCastWithExplicitType.kt") + public void testSmartCastWithExplicitType() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/SmartCastWithExplicitType.kt"); + } + + @Test + @TestMetadata("unresolvedReferenceInReturnBlock.kt") + public void testUnresolvedReferenceInReturnBlock() throws Exception { + runTest("compiler/testData/diagnostics/tests/functionLiterals/return/unresolvedReferenceInReturnBlock.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/generics") + @TestDataPath("$PROJECT_ROOT") + public class Generics { + @Test + public void testAllFilesPresentInGenerics() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("anonymousObjectSupertypeWithTypeParameterFromFunction.kt") + public void testAnonymousObjectSupertypeWithTypeParameterFromFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/anonymousObjectSupertypeWithTypeParameterFromFunction.kt"); + } + + @Test + @TestMetadata("approximationOfInProjection.kt") + public void testApproximationOfInProjection() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/approximationOfInProjection.kt"); + } + + @Test + @TestMetadata("argumentsForT.kt") + public void testArgumentsForT() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/argumentsForT.kt"); + } + + @Test + @TestMetadata("bareTypesWithStarProjections.kt") + public void testBareTypesWithStarProjections() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/bareTypesWithStarProjections.kt"); + } + + @Test + @TestMetadata("commonSupertypeContravariant.kt") + public void testCommonSupertypeContravariant() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/commonSupertypeContravariant.kt"); + } + + @Test + @TestMetadata("commonSupertypeContravariant2.kt") + public void testCommonSupertypeContravariant2() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/commonSupertypeContravariant2.kt"); + } + + @Test + @TestMetadata("doNotCaptureSupertype.kt") + public void testDoNotCaptureSupertype() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/doNotCaptureSupertype.kt"); + } + + @Test + @TestMetadata("finalUpperBoundWithOverride.kt") + public void testFinalUpperBoundWithOverride() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/finalUpperBoundWithOverride.kt"); + } + + @Test + @TestMetadata("finalUpperBoundWithoutOverride.kt") + public void testFinalUpperBoundWithoutOverride() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/finalUpperBoundWithoutOverride.kt"); + } + + @Test + @TestMetadata("genericsInType.kt") + public void testGenericsInType() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/genericsInType.kt"); + } + + @Test + @TestMetadata("InconsistentTypeParameterBounds.kt") + public void testInconsistentTypeParameterBounds() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/InconsistentTypeParameterBounds.kt"); + } + + @Test + @TestMetadata("invalidArgumentsNumberInWhere.kt") + public void testInvalidArgumentsNumberInWhere() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/invalidArgumentsNumberInWhere.kt"); + } + + @Test + @TestMetadata("kt1575-Class.kt") + public void testKt1575_Class() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/kt1575-Class.kt"); + } + + @Test + @TestMetadata("kt1575-Function.kt") + public void testKt1575_Function() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/kt1575-Function.kt"); + } + + @Test + @TestMetadata("kt30590.kt") + public void testKt30590() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/kt30590.kt"); + } + + @Test + @TestMetadata("kt34729.kt") + public void testKt34729() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/kt34729.kt"); + } + + @Test + @TestMetadata("kt53656.kt") + public void testKt53656() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/kt53656.kt"); + } + + @Test + @TestMetadata("kt5508.kt") + public void testKt5508() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/kt5508.kt"); + } + + @Test + @TestMetadata("kt9203.kt") + public void testKt9203() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/kt9203.kt"); + } + + @Test + @TestMetadata("kt9203_1.kt") + public void testKt9203_1() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/kt9203_1.kt"); + } + + @Test + @TestMetadata("kt9985.kt") + public void testKt9985() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/kt9985.kt"); + } + + @Test + @TestMetadata("localClassTypeRefWithTypeParameterFromFunction.kt") + public void testLocalClassTypeRefWithTypeParameterFromFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/localClassTypeRefWithTypeParameterFromFunction.kt"); + } + + @Test + @TestMetadata("Projections.kt") + public void testProjections() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/Projections.kt"); + } + + @Test + @TestMetadata("protectedSuperCall.kt") + public void testProtectedSuperCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/protectedSuperCall.kt"); + } + + @Test + @TestMetadata("PseudoRawTypes.kt") + public void testPseudoRawTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/PseudoRawTypes.kt"); + } + + @Test + @TestMetadata("RawTypeInIsExpression.kt") + public void testRawTypeInIsExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/RawTypeInIsExpression.kt"); + } + + @Test + @TestMetadata("RawTypeInIsPattern.kt") + public void testRawTypeInIsPattern() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/RawTypeInIsPattern.kt"); + } + + @Test + @TestMetadata("recursive.kt") + public void testRecursive() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/recursive.kt"); + } + + @Test + @TestMetadata("RecursiveUpperBoundCheck.kt") + public void testRecursiveUpperBoundCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/RecursiveUpperBoundCheck.kt"); + } + + @Test + @TestMetadata("RecursiveUpperBoundWithTwoArguments.kt") + public void testRecursiveUpperBoundWithTwoArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/RecursiveUpperBoundWithTwoArguments.kt"); + } + + @Test + @TestMetadata("resolveGenericBoundsBeforeSupertypes.kt") + public void testResolveGenericBoundsBeforeSupertypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/resolveGenericBoundsBeforeSupertypes.kt"); + } + + @Test + @TestMetadata("sameTypeParameterUse.kt") + public void testSameTypeParameterUse() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/sameTypeParameterUse.kt"); + } + + @Test + @TestMetadata("suppressVarianceConflict.kt") + public void testSuppressVarianceConflict() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/suppressVarianceConflict.kt"); + } + + @Test + @TestMetadata("TypeParameterBounds.kt") + public void testTypeParameterBounds() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/TypeParameterBounds.kt"); + } + + @Test + @TestMetadata("TypeParametersInTypeParameterBounds.kt") + public void testTypeParametersInTypeParameterBounds() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/TypeParametersInTypeParameterBounds.kt"); + } + + @Test + @TestMetadata("unresolvedClassifierInWhere.kt") + public void testUnresolvedClassifierInWhere() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/unresolvedClassifierInWhere.kt"); + } + + @Test + @TestMetadata("wildcardInValueParameter.kt") + public void testWildcardInValueParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/wildcardInValueParameter.kt"); + } + + @Test + @TestMetadata("wrongNumberOfTypeArgumentsDiagnostic.kt") + public void testWrongNumberOfTypeArgumentsDiagnostic() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/wrongNumberOfTypeArgumentsDiagnostic.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/generics/capturedParameters") + @TestDataPath("$PROJECT_ROOT") + public class CapturedParameters { + @Test + public void testAllFilesPresentInCapturedParameters() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/capturedParameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("captured.kt") + public void testCaptured() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/capturedParameters/captured.kt"); + } + + @Test + @TestMetadata("innerLocalClass.kt") + public void testInnerLocalClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/capturedParameters/innerLocalClass.kt"); + } + + @Test + @TestMetadata("localClass.kt") + public void testLocalClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/capturedParameters/localClass.kt"); + } + + @Test + @TestMetadata("localWithTypeParameter.kt") + public void testLocalWithTypeParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/capturedParameters/localWithTypeParameter.kt"); + } + + @Test + @TestMetadata("objectLiteral.kt") + public void testObjectLiteral() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/capturedParameters/objectLiteral.kt"); + } + + @Test + @TestMetadata("uncheckedCast.kt") + public void testUncheckedCast() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/capturedParameters/uncheckedCast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/generics/cyclicBounds") + @TestDataPath("$PROJECT_ROOT") + public class CyclicBounds { + @Test + public void testAllFilesPresentInCyclicBounds() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/cyclicBounds"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("functions.kt") + public void testFunctions() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/cyclicBounds/functions.kt"); + } + + @Test + @TestMetadata("inClass.kt") + public void testInClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/cyclicBounds/inClass.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/generics/innerClasses") + @TestDataPath("$PROJECT_ROOT") + public class InnerClasses { + @Test + public void testAllFilesPresentInInnerClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/innerClasses"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("bareTypes.kt") + public void testBareTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/bareTypes.kt"); + } + + @Test + @TestMetadata("bareTypesComplex.kt") + public void testBareTypesComplex() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/bareTypesComplex.kt"); + } + + @Test + @TestMetadata("checkBoundsOuter.kt") + public void testCheckBoundsOuter() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/checkBoundsOuter.kt"); + } + + @Test + @TestMetadata("importedInner.kt") + public void testImportedInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/importedInner.kt"); + } + + @Test + @TestMetadata("innerSuperCall.kt") + public void testInnerSuperCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/innerSuperCall.kt"); + } + + @Test + @TestMetadata("innerSuperCallSecondary.kt") + public void testInnerSuperCallSecondary() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/innerSuperCallSecondary.kt"); + } + + @Test + @TestMetadata("innerTP.kt") + public void testInnerTP() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/innerTP.kt"); + } + + @Test + @TestMetadata("innerUncheckedCast.kt") + public void testInnerUncheckedCast() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/innerUncheckedCast.kt"); + } + + @Test + @TestMetadata("innerVariance.kt") + public void testInnerVariance() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/innerVariance.kt"); + } + + @Test + @TestMetadata("iterator.kt") + public void testIterator() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/iterator.kt"); + } + + @Test + @TestMetadata("j+k.kt") + public void testJ_k() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/j+k.kt"); + } + + @Test + @TestMetadata("j+k_complex.kt") + public void testJ_k_complex() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/j+k_complex.kt"); + } + + @Test + @TestMetadata("kt3357.kt") + public void testKt3357() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/kt3357.kt"); + } + + @Test + @TestMetadata("kt408.kt") + public void testKt408() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/kt408.kt"); + } + + @Test + @TestMetadata("kt6325.kt") + public void testKt6325() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/kt6325.kt"); + } + + @Test + @TestMetadata("noTypeVarianceConflictInNestedClass.kt") + public void testNoTypeVarianceConflictInNestedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/noTypeVarianceConflictInNestedClass.kt"); + } + + @Test + @TestMetadata("outerArgumentsRequired.kt") + public void testOuterArgumentsRequired() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/outerArgumentsRequired.kt"); + } + + @Test + @TestMetadata("parameterShadowing.kt") + public void testParameterShadowing() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/parameterShadowing.kt"); + } + + @Test + @TestMetadata("qualifiedOuter.kt") + public void testQualifiedOuter() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedOuter.kt"); + } + + @Test + @TestMetadata("qualifiedTypesResolution.kt") + public void testQualifiedTypesResolution() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedTypesResolution.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/simple.kt"); + } + + @Test + @TestMetadata("simpleIn.kt") + public void testSimpleIn() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/simpleIn.kt"); + } + + @Test + @TestMetadata("simpleOut.kt") + public void testSimpleOut() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/simpleOut.kt"); + } + + @Test + @TestMetadata("simpleOutUseSite.kt") + public void testSimpleOutUseSite() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/simpleOutUseSite.kt"); + } + + @Test + @TestMetadata("substitutedMemberScope.kt") + public void testSubstitutedMemberScope() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/substitutedMemberScope.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments") + @TestDataPath("$PROJECT_ROOT") + public class ImplicitArguments { + @Test + public void testAllFilesPresentInImplicitArguments() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("fromCompanionObject_after.kt") + public void testFromCompanionObject_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromCompanionObject_after.kt"); + } + + @Test + @TestMetadata("fromCompanionObject_before.kt") + public void testFromCompanionObject_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromCompanionObject_before.kt"); + } + + @Test + @TestMetadata("fromOuterClassInObjectLiteral.kt") + public void testFromOuterClassInObjectLiteral() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromOuterClassInObjectLiteral.kt"); + } + + @Test + @TestMetadata("fromSuperClasses.kt") + public void testFromSuperClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClasses.kt"); + } + + @Test + @TestMetadata("fromSuperClassesLocal.kt") + public void testFromSuperClassesLocal() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocal.kt"); + } + + @Test + @TestMetadata("fromSuperClassesLocalInsideInner.kt") + public void testFromSuperClassesLocalInsideInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocalInsideInner.kt"); + } + + @Test + @TestMetadata("fromSuperClassesTransitive.kt") + public void testFromSuperClassesTransitive() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesTransitive.kt"); + } + + @Test + @TestMetadata("inStaticScope.kt") + public void testInStaticScope() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/inStaticScope.kt"); + } + + @Test + @TestMetadata("secondLevelDepth.kt") + public void testSecondLevelDepth() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/secondLevelDepth.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope") + @TestDataPath("$PROJECT_ROOT") + public class MultipleBoundsMemberScope { + @Test + public void testAllFilesPresentInMultipleBoundsMemberScope() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("conflictingReturnType.kt") + public void testConflictingReturnType() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/conflictingReturnType.kt"); + } + + @Test + @TestMetadata("flexibleTypes.kt") + public void testFlexibleTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/flexibleTypes.kt"); + } + + @Test + @TestMetadata("mostSpecific.kt") + public void testMostSpecific() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/mostSpecific.kt"); + } + + @Test + @TestMetadata("properties.kt") + public void testProperties() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/properties.kt"); + } + + @Test + @TestMetadata("propertiesConflict.kt") + public void testPropertiesConflict() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/propertiesConflict.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/simple.kt"); + } + + @Test + @TestMetadata("validTypeParameters.kt") + public void testValidTypeParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/validTypeParameters.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/generics/nullability") + @TestDataPath("$PROJECT_ROOT") + public class Nullability { + @Test + public void testAllFilesPresentInNullability() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/nullability"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("capturedTypeWithPlatformSupertype.kt") + public void testCapturedTypeWithPlatformSupertype() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/nullability/capturedTypeWithPlatformSupertype.kt"); + } + + @Test + @TestMetadata("considerTypeNotNullOnlyIfItHasNotNullBound.kt") + public void testConsiderTypeNotNullOnlyIfItHasNotNullBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/nullability/considerTypeNotNullOnlyIfItHasNotNullBound.kt"); + } + + @Test + @TestMetadata("correctSubstitutionForIncorporationConstraint.kt") + public void testCorrectSubstitutionForIncorporationConstraint() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/nullability/correctSubstitutionForIncorporationConstraint.kt"); + } + + @Test + @TestMetadata("declarationsBoundsViolation.kt") + public void testDeclarationsBoundsViolation() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/nullability/declarationsBoundsViolation.kt"); + } + + @Test + @TestMetadata("expressionsBoundsViolation.kt") + public void testExpressionsBoundsViolation() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/nullability/expressionsBoundsViolation.kt"); + } + + @Test + @TestMetadata("functionalBound.kt") + public void testFunctionalBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/nullability/functionalBound.kt"); + } + + @Test + @TestMetadata("inferNotNullTypeFromIntersectionOfNullableTypes.kt") + public void testInferNotNullTypeFromIntersectionOfNullableTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/nullability/inferNotNullTypeFromIntersectionOfNullableTypes.kt"); + } + + @Test + @TestMetadata("kt25182.kt") + public void testKt25182() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/nullability/kt25182.kt"); + } + + @Test + @TestMetadata("notNullSmartcastOnIntersectionOfNullables.kt") + public void testNotNullSmartcastOnIntersectionOfNullables() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/nullability/notNullSmartcastOnIntersectionOfNullables.kt"); + } + + @Test + @TestMetadata("nullToGeneric.kt") + public void testNullToGeneric() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/nullability/nullToGeneric.kt"); + } + + @Test + @TestMetadata("smartCastRefinedClass.kt") + public void testSmartCastRefinedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/nullability/smartCastRefinedClass.kt"); + } + + @Test + @TestMetadata("smartCasts.kt") + public void testSmartCasts() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/nullability/smartCasts.kt"); + } + + @Test + @TestMetadata("smartCastsOnThis.kt") + public void testSmartCastsOnThis() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/nullability/smartCastsOnThis.kt"); + } + + @Test + @TestMetadata("smartCastsValueArgument.kt") + public void testSmartCastsValueArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/nullability/smartCastsValueArgument.kt"); + } + + @Test + @TestMetadata("tpBoundsViolation.kt") + public void testTpBoundsViolation() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolation.kt"); + } + + @Test + @TestMetadata("tpBoundsViolationVariance.kt") + public void testTpBoundsViolationVariance() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolationVariance.kt"); + } + + @Test + @TestMetadata("tpInBounds.kt") + public void testTpInBounds() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/nullability/tpInBounds.kt"); + } + + @Test + @TestMetadata("useAsReceiver.kt") + public void testUseAsReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/nullability/useAsReceiver.kt"); + } + + @Test + @TestMetadata("useAsValueArgument.kt") + public void testUseAsValueArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/nullability/useAsValueArgument.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope") + @TestDataPath("$PROJECT_ROOT") + public class ProjectionsScope { + @Test + @TestMetadata("addAll.kt") + public void testAddAll() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/addAll.kt"); + } + + @Test + public void testAllFilesPresentInProjectionsScope() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/projectionsScope"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("approximateDispatchReceiver.kt") + public void testApproximateDispatchReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/approximateDispatchReceiver.kt"); + } + + @Test + @TestMetadata("extensionReceiverTypeMismatch.kt") + public void testExtensionReceiverTypeMismatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/extensionReceiverTypeMismatch.kt"); + } + + @Test + @TestMetadata("extensionResultSubstitution.kt") + public void testExtensionResultSubstitution() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/extensionResultSubstitution.kt"); + } + + @Test + @TestMetadata("flexibleProjectedScope.kt") + public void testFlexibleProjectedScope() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/flexibleProjectedScope.kt"); + } + + @Test + @TestMetadata("inValueParameter.kt") + public void testInValueParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/inValueParameter.kt"); + } + + @Test + @TestMetadata("iterateOnExtension.kt") + public void testIterateOnExtension() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/iterateOnExtension.kt"); + } + + @Test + @TestMetadata("kt7296.kt") + public void testKt7296() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/kt7296.kt"); + } + + @Test + @TestMetadata("kt8647.kt") + public void testKt8647() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/kt8647.kt"); + } + + @Test + @TestMetadata("lambdaArgument.kt") + public void testLambdaArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/lambdaArgument.kt"); + } + + @Test + @TestMetadata("leakedApproximatedType.kt") + public void testLeakedApproximatedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/leakedApproximatedType.kt"); + } + + @Test + @TestMetadata("MLOut.kt") + public void testMLOut() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/MLOut.kt"); + } + + @Test + @TestMetadata("multipleArgumentProjectedOut.kt") + public void testMultipleArgumentProjectedOut() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/multipleArgumentProjectedOut.kt"); + } + + @Test + @TestMetadata("platformSuperClass.kt") + public void testPlatformSuperClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/platformSuperClass.kt"); + } + + @Test + @TestMetadata("projectedOutConventions.kt") + public void testProjectedOutConventions() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutConventions.kt"); + } + + @Test + @TestMetadata("projectedOutSmartCast.kt") + public void testProjectedOutSmartCast() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutSmartCast.kt"); + } + + @Test + @TestMetadata("recursiveUpperBoundStar.kt") + public void testRecursiveUpperBoundStar() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/recursiveUpperBoundStar.kt"); + } + + @Test + @TestMetadata("recursiveUpperBoundStarOut.kt") + public void testRecursiveUpperBoundStarOut() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/recursiveUpperBoundStarOut.kt"); + } + + @Test + @TestMetadata("starNullability.kt") + public void testStarNullability() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/starNullability.kt"); + } + + @Test + @TestMetadata("starNullabilityRecursive.kt") + public void testStarNullabilityRecursive() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/starNullabilityRecursive.kt"); + } + + @Test + @TestMetadata("superClass.kt") + public void testSuperClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/superClass.kt"); + } + + @Test + @TestMetadata("typeMismatchConventions.kt") + public void testTypeMismatchConventions() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchConventions.kt"); + } + + @Test + @TestMetadata("typeMismatchInLambda.kt") + public void testTypeMismatchInLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchInLambda.kt"); + } + + @Test + @TestMetadata("typeParameterBounds.kt") + public void testTypeParameterBounds() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/typeParameterBounds.kt"); + } + + @Test + @TestMetadata("unsafeVarianceInAliasedFunctionalType.kt") + public void testUnsafeVarianceInAliasedFunctionalType() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/unsafeVarianceInAliasedFunctionalType.kt"); + } + + @Test + @TestMetadata("unsafeVarianceOnInputTypeOfFunctionalType.kt") + public void testUnsafeVarianceOnInputTypeOfFunctionalType() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/unsafeVarianceOnInputTypeOfFunctionalType.kt"); + } + + @Test + @TestMetadata("unsafeVarianceStar.kt") + public void testUnsafeVarianceStar() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/unsafeVarianceStar.kt"); + } + + @Test + @TestMetadata("unsafeVarianceWithRecursiveGenerics.kt") + public void testUnsafeVarianceWithRecursiveGenerics() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/unsafeVarianceWithRecursiveGenerics.kt"); + } + + @Test + @TestMetadata("varargs.kt") + public void testVarargs() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/varargs.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/generics/starProjections") + @TestDataPath("$PROJECT_ROOT") + public class StarProjections { + @Test + public void testAllFilesPresentInStarProjections() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/starProjections"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("checkBounds.kt") + public void testCheckBounds() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/starProjections/checkBounds.kt"); + } + + @Test + @TestMetadata("collectionInheritedFromJava.kt") + public void testCollectionInheritedFromJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/starProjections/collectionInheritedFromJava.kt"); + } + + @Test + @TestMetadata("foldRecursiveTypesToStarProjection.kt") + public void testFoldRecursiveTypesToStarProjection() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/starProjections/foldRecursiveTypesToStarProjection.kt"); + } + + @Test + @TestMetadata("inheritedFromJava.kt") + public void testInheritedFromJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/starProjections/inheritedFromJava.kt"); + } + + @Test + @TestMetadata("inheritedFromKotlin.kt") + public void testInheritedFromKotlin() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/starProjections/inheritedFromKotlin.kt"); + } + + @Test + @TestMetadata("invalid.kt") + public void testInvalid() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/starProjections/invalid.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/generics/tpAsReified") + @TestDataPath("$PROJECT_ROOT") + public class TpAsReified { + @Test + public void testAllFilesPresentInTpAsReified() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/tpAsReified"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("CapturedAsReified.kt") + public void testCapturedAsReified() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/CapturedAsReified.kt"); + } + + @Test + @TestMetadata("ClassDereference.kt") + public void testClassDereference() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/ClassDereference.kt"); + } + + @Test + @TestMetadata("Conventions.kt") + public void testConventions() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/Conventions.kt"); + } + + @Test + @TestMetadata("GenericArrayAsReifiedArgument.kt") + public void testGenericArrayAsReifiedArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/GenericArrayAsReifiedArgument.kt"); + } + + @Test + @TestMetadata("GenericArrayAsReifiedArgumentWarning.kt") + public void testGenericArrayAsReifiedArgumentWarning() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/GenericArrayAsReifiedArgumentWarning.kt"); + } + + @Test + @TestMetadata("GenericAsReifiedArgument.kt") + public void testGenericAsReifiedArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/GenericAsReifiedArgument.kt"); + } + + @Test + @TestMetadata("InConstructor.kt") + public void testInConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/InConstructor.kt"); + } + + @Test + @TestMetadata("InFunction.kt") + public void testInFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.kt"); + } + + @Test + @TestMetadata("InProperty.kt") + public void testInProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/InProperty.kt"); + } + + @Test + @TestMetadata("InType.kt") + public void testInType() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/InType.kt"); + } + + @Test + @TestMetadata("InlineableReified.kt") + public void testInlineableReified() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/InlineableReified.kt"); + } + + @Test + @TestMetadata("LocalFun.kt") + public void testLocalFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/LocalFun.kt"); + } + + @Test + @TestMetadata("NotInlineableReified.kt") + public void testNotInlineableReified() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/NotInlineableReified.kt"); + } + + @Test + @TestMetadata("ReifiedClass.kt") + public void testReifiedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/ReifiedClass.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/generics/varProjection") + @TestDataPath("$PROJECT_ROOT") + public class VarProjection { + @Test + public void testAllFilesPresentInVarProjection() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/varProjection"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("setterNotProjectedOutAssign.kt") + public void testSetterNotProjectedOutAssign() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/varProjection/setterNotProjectedOutAssign.kt"); + } + + @Test + @TestMetadata("setterProjectedOutAssign.kt") + public void testSetterProjectedOutAssign() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutAssign.kt"); + } + + @Test + @TestMetadata("setterProjectedOutNoPlusAssign.kt") + public void testSetterProjectedOutNoPlusAssign() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutNoPlusAssign.kt"); + } + + @Test + @TestMetadata("setterProjectedOutPlusAssignDefined.kt") + public void testSetterProjectedOutPlusAssignDefined() throws Exception { + runTest("compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutPlusAssignDefined.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/imports") + @TestDataPath("$PROJECT_ROOT") + public class Imports { + @Test + public void testAllFilesPresentInImports() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/imports"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("AllUnderImportsAmbiguity.kt") + public void testAllUnderImportsAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/AllUnderImportsAmbiguity.kt"); + } + + @Test + @TestMetadata("AllUnderImportsLessPriority.kt") + public void testAllUnderImportsLessPriority() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/AllUnderImportsLessPriority.kt"); + } + + @Test + @TestMetadata("AllUnderImportsSamePriorityForFunction.kt") + public void testAllUnderImportsSamePriorityForFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/AllUnderImportsSamePriorityForFunction.kt"); + } + + @Test + @TestMetadata("AllUnderImportsSamePriorityForProperty.kt") + public void testAllUnderImportsSamePriorityForProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/AllUnderImportsSamePriorityForProperty.kt"); + } + + @Test + @TestMetadata("CheckJavaVisibility.kt") + public void testCheckJavaVisibility() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/CheckJavaVisibility.kt"); + } + + @Test + @TestMetadata("CheckJavaVisibility2.kt") + public void testCheckJavaVisibility2() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/CheckJavaVisibility2.kt"); + } + + @Test + @TestMetadata("CheckVisibility.kt") + public void testCheckVisibility() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/CheckVisibility.kt"); + } + + @Test + @TestMetadata("ClassClash.kt") + public void testClassClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/ClassClash.kt"); + } + + @Test + @TestMetadata("ClassClashStarImport.kt") + public void testClassClashStarImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/ClassClashStarImport.kt"); + } + + @Test + @TestMetadata("ClassImportsConflicting.kt") + public void testClassImportsConflicting() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/ClassImportsConflicting.kt"); + } + + @Test + @TestMetadata("CurrentPackageAndAllUnderImport.kt") + public void testCurrentPackageAndAllUnderImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/CurrentPackageAndAllUnderImport.kt"); + } + + @Test + @TestMetadata("CurrentPackageAndExplicitImport.kt") + public void testCurrentPackageAndExplicitImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/CurrentPackageAndExplicitImport.kt"); + } + + @Test + @TestMetadata("DefaultImportsPriority.kt") + public void testDefaultImportsPriority() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/DefaultImportsPriority.kt"); + } + + @Test + @TestMetadata("DoubleImports.kt") + public void testDoubleImports() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/DoubleImports.kt"); + } + + @Test + @TestMetadata("EnumEntryVsStaticAmbiguity.kt") + public void testEnumEntryVsStaticAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/EnumEntryVsStaticAmbiguity.kt"); + } + + @Test + @TestMetadata("EnumEntryVsStaticAmbiguity2.kt") + public void testEnumEntryVsStaticAmbiguity2() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/EnumEntryVsStaticAmbiguity2.kt"); + } + + @Test + @TestMetadata("EnumEntryVsStaticAmbiguity3.kt") + public void testEnumEntryVsStaticAmbiguity3() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/EnumEntryVsStaticAmbiguity3.kt"); + } + + @Test + @TestMetadata("EnumEntryVsStaticAmbiguity4.kt") + public void testEnumEntryVsStaticAmbiguity4() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/EnumEntryVsStaticAmbiguity4.kt"); + } + + @Test + @TestMetadata("ExplicitImportsAmbiguity.kt") + public void testExplicitImportsAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/ExplicitImportsAmbiguity.kt"); + } + + @Test + @TestMetadata("ExplicitImportsUnambiguityForFunction.kt") + public void testExplicitImportsUnambiguityForFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/ExplicitImportsUnambiguityForFunction.kt"); + } + + @Test + @TestMetadata("ExplicitPackageImportsAmbiguity.kt") + public void testExplicitPackageImportsAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/ExplicitPackageImportsAmbiguity.kt"); + } + + @Test + @TestMetadata("ImportClassClash.kt") + public void testImportClassClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/ImportClassClash.kt"); + } + + @Test + @TestMetadata("ImportFromCompanionObject.kt") + public void testImportFromCompanionObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/ImportFromCompanionObject.kt"); + } + + @Test + @TestMetadata("ImportFromCurrentWithDifferentName.kt") + public void testImportFromCurrentWithDifferentName() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/ImportFromCurrentWithDifferentName.kt"); + } + + @Test + @TestMetadata("ImportFromObject.kt") + public void testImportFromObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/ImportFromObject.kt"); + } + + @Test + @TestMetadata("ImportFromRootPackage.kt") + public void testImportFromRootPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/ImportFromRootPackage.kt"); + } + + @Test + @TestMetadata("importFunctionWithAllUnderImport.kt") + public void testImportFunctionWithAllUnderImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/importFunctionWithAllUnderImport.kt"); + } + + @Test + @TestMetadata("importFunctionWithAllUnderImportAfterNamedImport.kt") + public void testImportFunctionWithAllUnderImportAfterNamedImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/importFunctionWithAllUnderImportAfterNamedImport.kt"); + } + + @Test + @TestMetadata("ImportFunctionWithPackageName.kt") + public void testImportFunctionWithPackageName() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/ImportFunctionWithPackageName.kt"); + } + + @Test + @TestMetadata("ImportHidingDefinitionInTheSameFile.kt") + public void testImportHidingDefinitionInTheSameFile() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/ImportHidingDefinitionInTheSameFile.kt"); + } + + @Test + @TestMetadata("ImportNestedWithDifferentName.kt") + public void testImportNestedWithDifferentName() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/ImportNestedWithDifferentName.kt"); + } + + @Test + @TestMetadata("ImportObjectAndUseAsSupertype.kt") + public void testImportObjectAndUseAsSupertype() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/ImportObjectAndUseAsSupertype.kt"); + } + + @Test + @TestMetadata("ImportObjectHidesCurrentPackage.kt") + public void testImportObjectHidesCurrentPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/ImportObjectHidesCurrentPackage.kt"); + } + + @Test + @TestMetadata("ImportOverloadFunctions.kt") + public void testImportOverloadFunctions() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/ImportOverloadFunctions.kt"); + } + + @Test + @TestMetadata("ImportPrivateMember.kt") + public void testImportPrivateMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/ImportPrivateMember.kt"); + } + + @Test + @TestMetadata("ImportPrivateMemberFromOtherFile.kt") + public void testImportPrivateMemberFromOtherFile() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/ImportPrivateMemberFromOtherFile.kt"); + } + + @Test + @TestMetadata("ImportPrivateMembersWithStar.kt") + public void testImportPrivateMembersWithStar() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/ImportPrivateMembersWithStar.kt"); + } + + @Test + @TestMetadata("ImportProtectedClass.kt") + public void testImportProtectedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/ImportProtectedClass.kt"); + } + + @Test + @TestMetadata("ImportResolutionOrder.kt") + public void testImportResolutionOrder() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/ImportResolutionOrder.kt"); + } + + @Test + @TestMetadata("ImportStaticFunctionWithNonStaticSibling.kt") + public void testImportStaticFunctionWithNonStaticSibling() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/ImportStaticFunctionWithNonStaticSibling.kt"); + } + + @Test + @TestMetadata("ImportTwoTimes.kt") + public void testImportTwoTimes() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/ImportTwoTimes.kt"); + } + + @Test + @TestMetadata("ImportTwoTimesStar.kt") + public void testImportTwoTimesStar() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/ImportTwoTimesStar.kt"); + } + + @Test + @TestMetadata("Imports.kt") + public void testImports() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/Imports.kt"); + } + + @Test + @TestMetadata("ImportsConflicting.kt") + public void testImportsConflicting() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/ImportsConflicting.kt"); + } + + @Test + @TestMetadata("InaccessiblePrivateClass.kt") + public void testInaccessiblePrivateClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/InaccessiblePrivateClass.kt"); + } + + @Test + @TestMetadata("InaccessiblePrivateInFile.kt") + public void testInaccessiblePrivateInFile() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/InaccessiblePrivateInFile.kt"); + } + + @Test + @TestMetadata("invisibleFakeReferenceInImport.kt") + public void testInvisibleFakeReferenceInImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/invisibleFakeReferenceInImport.kt"); + } + + @Test + @TestMetadata("JavaPackageLocalClassNotImported.kt") + public void testJavaPackageLocalClassNotImported() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/JavaPackageLocalClassNotImported.kt"); + } + + @Test + @TestMetadata("kt13112.kt") + public void testKt13112() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/kt13112.kt"); + } + + @Test + @TestMetadata("MalformedImports.kt") + public void testMalformedImports() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/MalformedImports.kt"); + } + + @Test + @TestMetadata("NestedClassClash.kt") + public void testNestedClassClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/NestedClassClash.kt"); + } + + @Test + @TestMetadata("OperatorRenameOnImport.kt") + public void testOperatorRenameOnImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/OperatorRenameOnImport.kt"); + } + + @Test + @TestMetadata("OptionalAnnotationClasses.kt") + public void testOptionalAnnotationClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/OptionalAnnotationClasses.kt"); + } + + @Test + @TestMetadata("PackageLocalClassNotImported.kt") + public void testPackageLocalClassNotImported() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/PackageLocalClassNotImported.kt"); + } + + @Test + @TestMetadata("PackageLocalClassReferencedError.kt") + public void testPackageLocalClassReferencedError() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/PackageLocalClassReferencedError.kt"); + } + + @Test + @TestMetadata("PackageVsClass.kt") + public void testPackageVsClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/PackageVsClass.kt"); + } + + @Test + @TestMetadata("PrivateClassNotImported.kt") + public void testPrivateClassNotImported() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/PrivateClassNotImported.kt"); + } + + @Test + @TestMetadata("PrivateClassReferencedError.kt") + public void testPrivateClassReferencedError() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/PrivateClassReferencedError.kt"); + } + + @Test + @TestMetadata("propertyClassFileDependencyRecursion.kt") + public void testPropertyClassFileDependencyRecursion() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/propertyClassFileDependencyRecursion.kt"); + } + + @Test + @TestMetadata("RenameOnImport.kt") + public void testRenameOnImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/RenameOnImport.kt"); + } + + @Test + @TestMetadata("StarImportFromObject.kt") + public void testStarImportFromObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/StarImportFromObject.kt"); + } + + @Test + @TestMetadata("SyntaxError.kt") + public void testSyntaxError() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/SyntaxError.kt"); + } + + @Test + @TestMetadata("TopLevelClassVsPackage.kt") + public void testTopLevelClassVsPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/TopLevelClassVsPackage.kt"); + } + + @Test + @TestMetadata("twoImportLists.kt") + public void testTwoImportLists() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/twoImportLists.kt"); + } + + @Test + @TestMetadata("WrongImport.kt") + public void testWrongImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/imports/WrongImport.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/incompleteCode") + @TestDataPath("$PROJECT_ROOT") + public class IncompleteCode { + @Test + public void testAllFilesPresentInIncompleteCode() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/incompleteCode"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("arrayBracketsRange.kt") + public void testArrayBracketsRange() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/arrayBracketsRange.kt"); + } + + @Test + @TestMetadata("checkNothingIsSubtype.kt") + public void testCheckNothingIsSubtype() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/checkNothingIsSubtype.kt"); + } + + @Test + @TestMetadata("controlStructuresErrors.kt") + public void testControlStructuresErrors() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/controlStructuresErrors.kt"); + } + + @Test + @TestMetadata("illegalSelectorCallableReference.kt") + public void testIllegalSelectorCallableReference() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/illegalSelectorCallableReference.kt"); + } + + @Test + @TestMetadata("inExpr.kt") + public void testInExpr() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/inExpr.kt"); + } + + @Test + @TestMetadata("incompleteAssignment.kt") + public void testIncompleteAssignment() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/incompleteAssignment.kt"); + } + + @Test + @TestMetadata("incompleteEquals.kt") + public void testIncompleteEquals() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/incompleteEquals.kt"); + } + + @Test + @TestMetadata("incompleteTryCatchBlock.kt") + public void testIncompleteTryCatchBlock() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/incompleteTryCatchBlock.kt"); + } + + @Test + @TestMetadata("kt1955.kt") + public void testKt1955() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/kt1955.kt"); + } + + @Test + @TestMetadata("kt2014.kt") + public void testKt2014() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/kt2014.kt"); + } + + @Test + @TestMetadata("kt4866UnresolvedArrayAccess.kt") + public void testKt4866UnresolvedArrayAccess() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/kt4866UnresolvedArrayAccess.kt"); + } + + @Test + @TestMetadata("NoSenselessComparisonForErrorType.kt") + public void testNoSenselessComparisonForErrorType() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/NoSenselessComparisonForErrorType.kt"); + } + + @Test + @TestMetadata("plusOnTheRight.kt") + public void testPlusOnTheRight() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/plusOnTheRight.kt"); + } + + @Test + @TestMetadata("pseudocodeTraverseNextInstructions.kt") + public void testPseudocodeTraverseNextInstructions() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/pseudocodeTraverseNextInstructions.kt"); + } + + @Test + @TestMetadata("senselessComparisonWithNull.kt") + public void testSenselessComparisonWithNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/senselessComparisonWithNull.kt"); + } + + @Test + @TestMetadata("SupertypeOfErrorType.kt") + public void testSupertypeOfErrorType() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/SupertypeOfErrorType.kt"); + } + + @Test + @TestMetadata("typeParameterOnLhsOfDot.kt") + public void testTypeParameterOnLhsOfDot() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/typeParameterOnLhsOfDot.kt"); + } + + @Test + @TestMetadata("unresolvedArguments.kt") + public void testUnresolvedArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/unresolvedArguments.kt"); + } + + @Test + @TestMetadata("unresolvedOperation.kt") + public void testUnresolvedOperation() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/unresolvedOperation.kt"); + } + + @Test + @TestMetadata("unresolvedTypeWithTypeArguments.kt") + public void testUnresolvedTypeWithTypeArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/unresolvedTypeWithTypeArguments.kt"); + } + + @Test + @TestMetadata("variableDeclarationInSelector.kt") + public void testVariableDeclarationInSelector() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/variableDeclarationInSelector.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError") + @TestDataPath("$PROJECT_ROOT") + public class DiagnosticWithSyntaxError { + @Test + public void testAllFilesPresentInDiagnosticWithSyntaxError() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("arrayExpression.kt") + public void testArrayExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/arrayExpression.kt"); + } + + @Test + @TestMetadata("checkBackingFieldException.kt") + public void testCheckBackingFieldException() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/checkBackingFieldException.kt"); + } + + @Test + @TestMetadata("completeFunctionArgumentsOfNestedCalls.kt") + public void testCompleteFunctionArgumentsOfNestedCalls() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/completeFunctionArgumentsOfNestedCalls.kt"); + } + + @Test + @TestMetadata("declarationAfterDotSelectorExpected.kt") + public void testDeclarationAfterDotSelectorExpected() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/declarationAfterDotSelectorExpected.kt"); + } + + @Test + @TestMetadata("declarationAfterIncompleteElvis.kt") + public void testDeclarationAfterIncompleteElvis() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/declarationAfterIncompleteElvis.kt"); + } + + @Test + @TestMetadata("funEquals.kt") + public void testFunEquals() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/funEquals.kt"); + } + + @Test + @TestMetadata("funKeyword.kt") + public void testFunKeyword() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/funKeyword.kt"); + } + + @Test + @TestMetadata("funcitonTypes.kt") + public void testFuncitonTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/funcitonTypes.kt"); + } + + @Test + @TestMetadata("incompleteEnumReference.kt") + public void testIncompleteEnumReference() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/incompleteEnumReference.kt"); + } + + @Test + @TestMetadata("incompleteVal.kt") + public void testIncompleteVal() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/incompleteVal.kt"); + } + + @Test + @TestMetadata("incompleteValWithAccessor.kt") + public void testIncompleteValWithAccessor() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/incompleteValWithAccessor.kt"); + } + + @Test + @TestMetadata("incompleteWhen.kt") + public void testIncompleteWhen() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/incompleteWhen.kt"); + } + + @Test + @TestMetadata("namedFun.kt") + public void testNamedFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/namedFun.kt"); + } + + @Test + @TestMetadata("noTypeParamsInReturnType.kt") + public void testNoTypeParamsInReturnType() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/noTypeParamsInReturnType.kt"); + } + + @Test + @TestMetadata("typeReferenceError.kt") + public void testTypeReferenceError() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/typeReferenceError.kt"); + } + + @Test + @TestMetadata("valNoName.kt") + public void testValNoName() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/valNoName.kt"); + } + + @Test + @TestMetadata("valWithNoNameBeforeNextDeclarationWithModifiers.kt") + public void testValWithNoNameBeforeNextDeclarationWithModifiers() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/valWithNoNameBeforeNextDeclarationWithModifiers.kt"); + } + + @Test + @TestMetadata("valWithNoNameInBlock.kt") + public void testValWithNoNameInBlock() throws Exception { + runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/valWithNoNameInBlock.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inference") + @TestDataPath("$PROJECT_ROOT") + public class Inference { + @Test + public void testAllFilesPresentInInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("annotatedUnderscoredTypeArgument.kt") + public void testAnnotatedUnderscoredTypeArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/annotatedUnderscoredTypeArgument.kt"); + } + + @Test + @TestMetadata("cannotCompleteResolveAmbiguity.kt") + public void testCannotCompleteResolveAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/cannotCompleteResolveAmbiguity.kt"); + } + + @Test + @TestMetadata("cannotCompleteResolveFunctionLiteralsNoUse.kt") + public void testCannotCompleteResolveFunctionLiteralsNoUse() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/cannotCompleteResolveFunctionLiteralsNoUse.kt"); + } + + @Test + @TestMetadata("cannotCompleteResolveNoInfoForParameter.kt") + public void testCannotCompleteResolveNoInfoForParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/cannotCompleteResolveNoInfoForParameter.kt"); + } + + @Test + @TestMetadata("cannotCompleteResolveNoneApplicable.kt") + public void testCannotCompleteResolveNoneApplicable() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/cannotCompleteResolveNoneApplicable.kt"); + } + + @Test + @TestMetadata("cannotCompleteResolveWithFunctionLiterals.kt") + public void testCannotCompleteResolveWithFunctionLiterals() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/cannotCompleteResolveWithFunctionLiterals.kt"); + } + + @Test + @TestMetadata("capturedInProjectedFlexibleType.kt") + public void testCapturedInProjectedFlexibleType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedInProjectedFlexibleType.kt"); + } + + @Test + @TestMetadata("capturedTypesInSelfType.kt") + public void testCapturedTypesInSelfType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypesInSelfType.kt"); + } + + @Test + @TestMetadata("coerceFunctionLiteralToSuspend.kt") + public void testCoerceFunctionLiteralToSuspend() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/coerceFunctionLiteralToSuspend.kt"); + } + + @Test + @TestMetadata("commonSuperTypeOfErrorTypes.kt") + public void testCommonSuperTypeOfErrorTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSuperTypeOfErrorTypes.kt"); + } + + @Test + @TestMetadata("commonSuperTypeOfTypesWithErrorSupertypes.kt") + public void testCommonSuperTypeOfTypesWithErrorSupertypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSuperTypeOfTypesWithErrorSupertypes.kt"); + } + + @Test + @TestMetadata("completeInferenceIfManyFailed.kt") + public void testCompleteInferenceIfManyFailed() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completeInferenceIfManyFailed.kt"); + } + + @Test + @TestMetadata("completionOfMultipleLambdas.kt") + public void testCompletionOfMultipleLambdas() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completionOfMultipleLambdas.kt"); + } + + @Test + @TestMetadata("conflictingSubstitutions.kt") + public void testConflictingSubstitutions() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/conflictingSubstitutions.kt"); + } + + @Test + @TestMetadata("cstFromErrorAndNonErrorTypes.kt") + public void testCstFromErrorAndNonErrorTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/cstFromErrorAndNonErrorTypes.kt"); + } + + @Test + @TestMetadata("dependOnExpectedType.kt") + public void testDependOnExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/dependOnExpectedType.kt"); + } + + @Test + @TestMetadata("dependantOnVariance.kt") + public void testDependantOnVariance() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/dependantOnVariance.kt"); + } + + @Test + @TestMetadata("dependantOnVarianceNullable.kt") + public void testDependantOnVarianceNullable() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/dependantOnVarianceNullable.kt"); + } + + @Test + @TestMetadata("discardInapplicableCandidateWithNotSatisfyingSelfType.kt") + public void testDiscardInapplicableCandidateWithNotSatisfyingSelfType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/discardInapplicableCandidateWithNotSatisfyingSelfType.kt"); + } + + @Test + @TestMetadata("dontThrowEmptyIntersectionException.kt") + public void testDontThrowEmptyIntersectionException() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/dontThrowEmptyIntersectionException.kt"); + } + + @Test + @TestMetadata("elvisInsideWhen.kt") + public void testElvisInsideWhen() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/elvisInsideWhen.kt"); + } + + @Test + @TestMetadata("equalitySubstitutionInsideNonInvariantType.kt") + public void testEqualitySubstitutionInsideNonInvariantType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/equalitySubstitutionInsideNonInvariantType.kt"); + } + + @Test + @TestMetadata("errorsOnImplicitInvokeInSimpleCall.kt") + public void testErrorsOnImplicitInvokeInSimpleCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/errorsOnImplicitInvokeInSimpleCall.kt"); + } + + @Test + @TestMetadata("expectedTypeAdditionalTest.kt") + public void testExpectedTypeAdditionalTest() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/expectedTypeAdditionalTest.kt"); + } + + @Test + @TestMetadata("expectedTypeDoubleReceiver.kt") + public void testExpectedTypeDoubleReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/expectedTypeDoubleReceiver.kt"); + } + + @Test + @TestMetadata("expectedTypeFromCast.kt") + public void testExpectedTypeFromCast() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/expectedTypeFromCast.kt"); + } + + @Test + @TestMetadata("expectedTypeFromCastComplexExpression.kt") + public void testExpectedTypeFromCastComplexExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/expectedTypeFromCastComplexExpression.kt"); + } + + @Test + @TestMetadata("expectedTypeFromCastParenthesized.kt") + public void testExpectedTypeFromCastParenthesized() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/expectedTypeFromCastParenthesized.kt"); + } + + @Test + @TestMetadata("expectedTypeWithGenerics.kt") + public void testExpectedTypeWithGenerics() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/expectedTypeWithGenerics.kt"); + } + + @Test + @TestMetadata("expectedTypeWithGenericsSafeCalls.kt") + public void testExpectedTypeWithGenericsSafeCalls() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/expectedTypeWithGenericsSafeCalls.kt"); + } + + @Test + @TestMetadata("extensionLambdasAndArrow.kt") + public void testExtensionLambdasAndArrow() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/extensionLambdasAndArrow.kt"); + } + + @Test + @TestMetadata("findViewById.kt") + public void testFindViewById() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/findViewById.kt"); + } + + @Test + @TestMetadata("fixVariableToNothing.kt") + public void testFixVariableToNothing() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/fixVariableToNothing.kt"); + } + + @Test + @TestMetadata("fixationOrderForProperConstraints.kt") + public void testFixationOrderForProperConstraints() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/fixationOrderForProperConstraints.kt"); + } + + @Test + @TestMetadata("flexibleTypesAsUpperBound.kt") + public void testFlexibleTypesAsUpperBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/flexibleTypesAsUpperBound.kt"); + } + + @Test + @TestMetadata("functionPlaceholderError.kt") + public void testFunctionPlaceholderError() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/functionPlaceholderError.kt"); + } + + @Test + @TestMetadata("genericAssignmentOperator.kt") + public void testGenericAssignmentOperator() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/genericAssignmentOperator.kt"); + } + + @Test + @TestMetadata("hasErrorInConstrainingTypes.kt") + public void testHasErrorInConstrainingTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/hasErrorInConstrainingTypes.kt"); + } + + @Test + @TestMetadata("ifWithDependentBranches.kt") + public void testIfWithDependentBranches() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/ifWithDependentBranches.kt"); + } + + @Test + @TestMetadata("illegalUnderscoredTypeArgument.kt") + public void testIllegalUnderscoredTypeArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/illegalUnderscoredTypeArgument.kt"); + } + + @Test + @TestMetadata("immutableArrayList.kt") + public void testImmutableArrayList() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/immutableArrayList.kt"); + } + + @Test + @TestMetadata("implicitInvokeExtensionWithFunctionalArgument.kt") + public void testImplicitInvokeExtensionWithFunctionalArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/implicitInvokeExtensionWithFunctionalArgument.kt"); + } + + @Test + @TestMetadata("implicitInvokeInCompanionObjectWithFunctionalArgument.kt") + public void testImplicitInvokeInCompanionObjectWithFunctionalArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/implicitInvokeInCompanionObjectWithFunctionalArgument.kt"); + } + + @Test + @TestMetadata("implicitInvokeInObjectWithFunctionalArgument.kt") + public void testImplicitInvokeInObjectWithFunctionalArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/implicitInvokeInObjectWithFunctionalArgument.kt"); + } + + @Test + @TestMetadata("implicitInvokeWithFunctionLiteralArgument.kt") + public void testImplicitInvokeWithFunctionLiteralArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/implicitInvokeWithFunctionLiteralArgument.kt"); + } + + @Test + @TestMetadata("inferInFunctionLiterals.kt") + public void testInferInFunctionLiterals() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/inferInFunctionLiterals.kt"); + } + + @Test + @TestMetadata("inferInFunctionLiteralsWithReturn.kt") + public void testInferInFunctionLiteralsWithReturn() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/inferInFunctionLiteralsWithReturn.kt"); + } + + @Test + @TestMetadata("inferenceForkRegression.kt") + public void testInferenceForkRegression() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/inferenceForkRegression.kt"); + } + + @Test + @TestMetadata("inferenceForkRegressionSimple.kt") + public void testInferenceForkRegressionSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/inferenceForkRegressionSimple.kt"); + } + + @Test + @TestMetadata("intersectionTypeMultipleBoundsAsReceiver.kt") + public void testIntersectionTypeMultipleBoundsAsReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/intersectionTypeMultipleBoundsAsReceiver.kt"); + } + + @Test + @TestMetadata("intersectionTypesWithContravariantTypes.kt") + public void testIntersectionTypesWithContravariantTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/intersectionTypesWithContravariantTypes.kt"); + } + + @Test + @TestMetadata("intersectionWithEnum.kt") + public void testIntersectionWithEnum() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/intersectionWithEnum.kt"); + } + + @Test + @TestMetadata("invokeLambdaAsFunction.kt") + public void testInvokeLambdaAsFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/invokeLambdaAsFunction.kt"); + } + + @Test + @TestMetadata("knownTypeParameters.kt") + public void testKnownTypeParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/knownTypeParameters.kt"); + } + + @Test + @TestMetadata("kt11963.kt") + public void testKt11963() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt11963.kt"); + } + + @Test + @TestMetadata("kt12399.kt") + public void testKt12399() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt12399.kt"); + } + + @Test + @TestMetadata("kt1293.kt") + public void testKt1293() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt1293.kt"); + } + + @Test + @TestMetadata("kt28598.kt") + public void testKt28598() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt28598.kt"); + } + + @Test + @TestMetadata("kt28654.kt") + public void testKt28654() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt28654.kt"); + } + + @Test + @TestMetadata("kt30405.kt") + public void testKt30405() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt30405.kt"); + } + + @Test + @TestMetadata("kt3184.kt") + public void testKt3184() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt3184.kt"); + } + + @Test + @TestMetadata("kt32196.kt") + public void testKt32196() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt32196.kt"); + } + + @Test + @TestMetadata("kt32415.kt") + public void testKt32415() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt32415.kt"); + } + + @Test + @TestMetadata("kt32434.kt") + public void testKt32434() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt32434.kt"); + } + + @Test + @TestMetadata("kt32462.kt") + public void testKt32462() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt32462.kt"); + } + + @Test + @TestMetadata("kt33263.kt") + public void testKt33263() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt33263.kt"); + } + + @Test + @TestMetadata("kt35702.kt") + public void testKt35702() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt35702.kt"); + } + + @Test + @TestMetadata("kt36044.kt") + public void testKt36044() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt36044.kt"); + } + + @Test + @TestMetadata("kt36819.kt") + public void testKt36819() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt36819.kt"); + } + + @Test + @TestMetadata("kt37853.kt") + public void testKt37853() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt37853.kt"); + } + + @Test + @TestMetadata("kt39220.kt") + public void testKt39220() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt39220.kt"); + } + + @Test + @TestMetadata("kt40396.kt") + public void testKt40396() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt40396.kt"); + } + + @Test + @TestMetadata("kt46515.kt") + public void testKt46515() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt46515.kt"); + } + + @Test + @TestMetadata("kt47316.kt") + public void testKt47316() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt47316.kt"); + } + + @Test + @TestMetadata("kt49658.kt") + public void testKt49658() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt49658.kt"); + } + + @Test + @TestMetadata("kt49658Strict.kt") + public void testKt49658Strict() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt49658Strict.kt"); + } + + @Test + @TestMetadata("kt49961.kt") + public void testKt49961() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt49961.kt"); + } + + @Test + @TestMetadata("kt50232a.kt") + public void testKt50232a() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt50232a.kt"); + } + + @Test + @TestMetadata("kt53124.kt") + public void testKt53124() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt53124.kt"); + } + + @Test + @TestMetadata("kt6175.kt") + public void testKt6175() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt6175.kt"); + } + + @Test + @TestMetadata("kt619.kt") + public void testKt619() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt619.kt"); + } + + @Test + @TestMetadata("lambdaArgumentWithLabel.kt") + public void testLambdaArgumentWithLabel() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/lambdaArgumentWithLabel.kt"); + } + + @Test + @TestMetadata("lambdaInValInitializerWithAnonymousFunctions.kt") + public void testLambdaInValInitializerWithAnonymousFunctions() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/lambdaInValInitializerWithAnonymousFunctions.kt"); + } + + @Test + @TestMetadata("lambdaParameterTypeInElvis.kt") + public void testLambdaParameterTypeInElvis() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/lambdaParameterTypeInElvis.kt"); + } + + @Test + @TestMetadata("listConstructor.kt") + public void testListConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/listConstructor.kt"); + } + + @Test + @TestMetadata("localFunctionInsideIfBlock.kt") + public void testLocalFunctionInsideIfBlock() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/localFunctionInsideIfBlock.kt"); + } + + @Test + @TestMetadata("mapFunction.kt") + public void testMapFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/mapFunction.kt"); + } + + @Test + @TestMetadata("mostSpecificAfterInference.kt") + public void testMostSpecificAfterInference() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/mostSpecificAfterInference.kt"); + } + + @Test + @TestMetadata("NoInferenceFromDeclaredBounds.kt") + public void testNoInferenceFromDeclaredBounds() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/NoInferenceFromDeclaredBounds.kt"); + } + + @Test + @TestMetadata("noInformationForParameter.kt") + public void testNoInformationForParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/noInformationForParameter.kt"); + } + + @Test + @TestMetadata("nonFunctionalExpectedTypeForLambdaArgument.kt") + public void testNonFunctionalExpectedTypeForLambdaArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nonFunctionalExpectedTypeForLambdaArgument.kt"); + } + + @Test + @TestMetadata("nothingVsParameterBound.kt") + public void testNothingVsParameterBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingVsParameterBound.kt"); + } + + @Test + @TestMetadata("nullableTypeArgumentWithNotNullUpperBound.kt") + public void testNullableTypeArgumentWithNotNullUpperBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nullableTypeArgumentWithNotNullUpperBound.kt"); + } + + @Test + @TestMetadata("nullableUpperBound.kt") + public void testNullableUpperBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nullableUpperBound.kt"); + } + + @Test + @TestMetadata("onlyInputTypesWithMultilevelIncorporation.kt") + public void testOnlyInputTypesWithMultilevelIncorporation() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/onlyInputTypesWithMultilevelIncorporation.kt"); + } + + @Test + @TestMetadata("opposite.kt") + public void testOpposite() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/opposite.kt"); + } + + @Test + @TestMetadata("possibleCycleOnConstraints.kt") + public void testPossibleCycleOnConstraints() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/possibleCycleOnConstraints.kt"); + } + + @Test + @TestMetadata("reportAboutUnresolvedReferenceAsUnresolved.kt") + public void testReportAboutUnresolvedReferenceAsUnresolved() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/reportAboutUnresolvedReferenceAsUnresolved.kt"); + } + + @Test + @TestMetadata("reportNotEnoughTypeInformationErrorsOnBlockExpressions.kt") + public void testReportNotEnoughTypeInformationErrorsOnBlockExpressions() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/reportNotEnoughTypeInformationErrorsOnBlockExpressions.kt"); + } + + @Test + @TestMetadata("resolveWithUnknownLambdaParameterType.kt") + public void testResolveWithUnknownLambdaParameterType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/resolveWithUnknownLambdaParameterType.kt"); + } + + @Test + @TestMetadata("returningLambdaInSuspendContext.kt") + public void testReturningLambdaInSuspendContext() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/returningLambdaInSuspendContext.kt"); + } + + @Test + @TestMetadata("selectOfLambdaWithExtension.kt") + public void testSelectOfLambdaWithExtension() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/selectOfLambdaWithExtension.kt"); + } + + @Test + @TestMetadata("selectOfLambdaWithExtensionDisabled.kt") + public void testSelectOfLambdaWithExtensionDisabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/selectOfLambdaWithExtensionDisabled.kt"); + } + + @Test + @TestMetadata("selectOfLambdaWithExtensionEnabled.kt") + public void testSelectOfLambdaWithExtensionEnabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/selectOfLambdaWithExtensionEnabled.kt"); + } + + @Test + @TestMetadata("smartCastFork.kt") + public void testSmartCastFork() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/smartCastFork.kt"); + } + + @Test + @TestMetadata("smartCastForkForExpectType.kt") + public void testSmartCastForkForExpectType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/smartCastForkForExpectType.kt"); + } + + @Test + @TestMetadata("smartCastForkForExpectedTypeNested.kt") + public void testSmartCastForkForExpectedTypeNested() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/smartCastForkForExpectedTypeNested.kt"); + } + + @Test + @TestMetadata("specialCallsWithCallableReferences.kt") + public void testSpecialCallsWithCallableReferences() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/specialCallsWithCallableReferences.kt"); + } + + @Test + @TestMetadata("specialCallsWithLambdas.kt") + public void testSpecialCallsWithLambdas() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/specialCallsWithLambdas.kt"); + } + + @Test + @TestMetadata("starApproximation.kt") + public void testStarApproximation() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/starApproximation.kt"); + } + + @Test + @TestMetadata("starApproximationBangBang.kt") + public void testStarApproximationBangBang() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/starApproximationBangBang.kt"); + } + + @Test + @TestMetadata("starApproximationFlexible.kt") + public void testStarApproximationFlexible() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/starApproximationFlexible.kt"); + } + + @Test + @TestMetadata("starApproximationFromDifferentTypeParameter.kt") + public void testStarApproximationFromDifferentTypeParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/starApproximationFromDifferentTypeParameter.kt"); + } + + @Test + @TestMetadata("stubTypeForSubtyping.kt") + public void testStubTypeForSubtyping() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/stubTypeForSubtyping.kt"); + } + + @Test + @TestMetadata("tooEagerSmartcast.kt") + public void testTooEagerSmartcast() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/tooEagerSmartcast.kt"); + } + + @Test + @TestMetadata("topLevelIntersection.kt") + public void testTopLevelIntersection() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/topLevelIntersection.kt"); + } + + @Test + @TestMetadata("tryNumberLowerBoundsBeforeUpperBounds.kt") + public void testTryNumberLowerBoundsBeforeUpperBounds() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/tryNumberLowerBoundsBeforeUpperBounds.kt"); + } + + @Test + @TestMetadata("typeConstructorMismatch.kt") + public void testTypeConstructorMismatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/typeConstructorMismatch.kt"); + } + + @Test + @TestMetadata("typeInferenceExpectedTypeMismatch.kt") + public void testTypeInferenceExpectedTypeMismatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/typeInferenceExpectedTypeMismatch.kt"); + } + + @Test + @TestMetadata("typeParameterInConstructor.kt") + public void testTypeParameterInConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/typeParameterInConstructor.kt"); + } + + @Test + @TestMetadata("underscoredTypeArgument.kt") + public void testUnderscoredTypeArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/underscoredTypeArgument.kt"); + } + + @Test + @TestMetadata("underscoredTypeInForbiddenPositions.kt") + public void testUnderscoredTypeInForbiddenPositions() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/underscoredTypeInForbiddenPositions.kt"); + } + + @Test + @TestMetadata("unsoundness1.kt") + public void testUnsoundness1() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/unsoundness1.kt"); + } + + @Test + @TestMetadata("unsoundness2.kt") + public void testUnsoundness2() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/unsoundness2.kt"); + } + + @Test + @TestMetadata("useFunctionLiteralsToInferType.kt") + public void testUseFunctionLiteralsToInferType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/useFunctionLiteralsToInferType.kt"); + } + + @Test + @TestMetadata("violatingUpperBoundForSelfType.kt") + public void testViolatingUpperBoundForSelfType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/violatingUpperBoundForSelfType.kt"); + } + + @Test + @TestMetadata("violatingUpperBoundForSelfTypeError.kt") + public void testViolatingUpperBoundForSelfTypeError() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/violatingUpperBoundForSelfTypeError.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inference/builderInference") + @TestDataPath("$PROJECT_ROOT") + public class BuilderInference { + @Test + public void testAllFilesPresentInBuilderInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/builderInference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("changingResolveIfDontUseBuilderInference.kt") + public void testChangingResolveIfDontUseBuilderInference() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/changingResolveIfDontUseBuilderInference.kt"); + } + + @Test + @TestMetadata("equalityChecksOnIntegerTypes.kt") + public void testEqualityChecksOnIntegerTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/equalityChecksOnIntegerTypes.kt"); + } + + @Test + @TestMetadata("equalityChecksOnIntegerTypesProgressive.kt") + public void testEqualityChecksOnIntegerTypesProgressive() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/equalityChecksOnIntegerTypesProgressive.kt"); + } + + @Test + @TestMetadata("errorOnStubReceiver.kt") + public void testErrorOnStubReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/errorOnStubReceiver.kt"); + } + + @Test + @TestMetadata("invalidateKeys.kt") + public void testInvalidateKeys() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/invalidateKeys.kt"); + } + + @Test + @TestMetadata("kt47744.kt") + public void testKt47744() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/kt47744.kt"); + } + + @Test + @TestMetadata("kt47986Default.kt") + public void testKt47986Default() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/kt47986Default.kt"); + } + + @Test + @TestMetadata("kt47986Disabled.kt") + public void testKt47986Disabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/kt47986Disabled.kt"); + } + + @Test + @TestMetadata("kt47986Enabled.kt") + public void testKt47986Enabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/kt47986Enabled.kt"); + } + + @Test + @TestMetadata("kt47986_2.kt") + public void testKt47986_2() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/kt47986_2.kt"); + } + + @Test + @TestMetadata("kt47986_3.kt") + public void testKt47986_3() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/kt47986_3.kt"); + } + + @Test + @TestMetadata("kt47986_4.kt") + public void testKt47986_4() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/kt47986_4.kt"); + } + + @Test + @TestMetadata("kt48031.kt") + public void testKt48031() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/kt48031.kt"); + } + + @Test + @TestMetadata("kt49285.kt") + public void testKt49285() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/kt49285.kt"); + } + + @Test + @TestMetadata("kt49828.kt") + public void testKt49828() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/kt49828.kt"); + } + + @Test + @TestMetadata("kt49829.kt") + public void testKt49829() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/kt49829.kt"); + } + + @Test + @TestMetadata("kt50498.kt") + public void testKt50498() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/kt50498.kt"); + } + + @Test + @TestMetadata("kt50989.kt") + public void testKt50989() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/kt50989.kt"); + } + + @Test + @TestMetadata("kt51148.kt") + public void testKt51148() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/kt51148.kt"); + } + + @Test + @TestMetadata("kt51464.kt") + public void testKt51464() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/kt51464.kt"); + } + + @Test + @TestMetadata("kt53422.kt") + public void testKt53422() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/kt53422.kt"); + } + + @Test + @TestMetadata("kt53639.kt") + public void testKt53639() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/kt53639.kt"); + } + + @Test + @TestMetadata("labaledCall.kt") + public void testLabaledCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/labaledCall.kt"); + } + + @Test + @TestMetadata("multiLambdaRestriction.kt") + public void testMultiLambdaRestriction() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/multiLambdaRestriction.kt"); + } + + @Test + @TestMetadata("multiLambdaRestrictionDisabled.kt") + public void testMultiLambdaRestrictionDisabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/multiLambdaRestrictionDisabled.kt"); + } + + @Test + @TestMetadata("noBuilderInferenceRestrictionReceiverInconsistency.kt") + public void testNoBuilderInferenceRestrictionReceiverInconsistency() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/noBuilderInferenceRestrictionReceiverInconsistency.kt"); + } + + @Test + @TestMetadata("propertySubstitution.kt") + public void testPropertySubstitution() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/propertySubstitution.kt"); + } + + @Test + @TestMetadata("simpleLambdaInCallWithAnotherLambdaWithBuilderInference.kt") + public void testSimpleLambdaInCallWithAnotherLambdaWithBuilderInference() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/simpleLambdaInCallWithAnotherLambdaWithBuilderInference.kt"); + } + + @Test + @TestMetadata("skipedUnresolvedInBuilderInferenceWithStubReceiverType.kt") + public void testSkipedUnresolvedInBuilderInferenceWithStubReceiverType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/skipedUnresolvedInBuilderInferenceWithStubReceiverType.kt"); + } + + @Test + @TestMetadata("specialCallsWithCallableReferences.kt") + public void testSpecialCallsWithCallableReferences() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferences.kt"); + } + + @Test + @TestMetadata("specialCallsWithCallableReferencesDontCareTypeInBlockExression.kt") + public void testSpecialCallsWithCallableReferencesDontCareTypeInBlockExression() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExression.kt"); + } + + @Test + @TestMetadata("specialCallsWithCallableReferencesDontRewriteAtSlice.kt") + public void testSpecialCallsWithCallableReferencesDontRewriteAtSlice() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesDontRewriteAtSlice.kt"); + } + + @Test + @TestMetadata("specialCallsWithCallableReferencesErrorType.kt") + public void testSpecialCallsWithCallableReferencesErrorType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorType.kt"); + } + + @Test + @TestMetadata("specialCallsWithCallableReferencesErrorTypeUnrestricted.kt") + public void testSpecialCallsWithCallableReferencesErrorTypeUnrestricted() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorTypeUnrestricted.kt"); + } + + @Test + @TestMetadata("specialCallsWithCallableReferencesNonStrictOnlyInputTypes.kt") + public void testSpecialCallsWithCallableReferencesNonStrictOnlyInputTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesNonStrictOnlyInputTypes.kt"); + } + + @Test + @TestMetadata("specialCallsWithCallableReferencesUnrestricted.kt") + public void testSpecialCallsWithCallableReferencesUnrestricted() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesUnrestricted.kt"); + } + + @Test + @TestMetadata("specialCallsWithLambdas.kt") + public void testSpecialCallsWithLambdas() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithLambdas.kt"); + } + + @Test + @TestMetadata("withoutAnnotationDisabledFeature.kt") + public void testWithoutAnnotationDisabledFeature() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/withoutAnnotationDisabledFeature.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inference/builderInference/constraints") + @TestDataPath("$PROJECT_ROOT") + public class Constraints { + @Test + public void testAllFilesPresentInConstraints() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/builderInference/constraints"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("violating.kt") + public void testViolating() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/constraints/violating.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inference/builderInference/stubTypes") + @TestDataPath("$PROJECT_ROOT") + public class StubTypes { + @Test + public void testAllFilesPresentInStubTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/builderInference/stubTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("capturedTypes.kt") + public void testCapturedTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/capturedTypes.kt"); + } + + @Test + @TestMetadata("commonSuperType.kt") + public void testCommonSuperType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperType.kt"); + } + + @Test + @TestMetadata("commonSuperTypeContravariant.kt") + public void testCommonSuperTypeContravariant() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeContravariant.kt"); + } + + @Test + @TestMetadata("commonSuperTypeCovariant.kt") + public void testCommonSuperTypeCovariant() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeCovariant.kt"); + } + + @Test + @TestMetadata("commonSuperTypeInvariant.kt") + public void testCommonSuperTypeInvariant() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeInvariant.kt"); + } + + @Test + @TestMetadata("commonSuperTypeNullable.kt") + public void testCommonSuperTypeNullable() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeNullable.kt"); + } + + @Test + @TestMetadata("intersect.kt") + public void testIntersect() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/intersect.kt"); + } + + @Test + @TestMetadata("memberScope.kt") + public void testMemberScope() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/memberScope.kt"); + } + + @Test + @TestMetadata("nullability.kt") + public void testNullability() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/nullability.kt"); + } + + @Test + @TestMetadata("renderingStubTypes.kt") + public void testRenderingStubTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/renderingStubTypes.kt"); + } + + @Test + @TestMetadata("stubTypeReceiverRestriction.kt") + public void testStubTypeReceiverRestriction() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/stubTypeReceiverRestriction.kt"); + } + + @Test + @TestMetadata("stubTypeReceiverRestrictionDisabled.kt") + public void testStubTypeReceiverRestrictionDisabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/stubTypeReceiverRestrictionDisabled.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inference/callableReferences") + @TestDataPath("$PROJECT_ROOT") + public class CallableReferences { + @Test + public void testAllFilesPresentInCallableReferences() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/callableReferences"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("conversionLastStatementInLambda.kt") + public void testConversionLastStatementInLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/callableReferences/conversionLastStatementInLambda.kt"); + } + + @Test + @TestMetadata("kt55931.kt") + public void testKt55931() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/callableReferences/kt55931.kt"); + } + + @Test + @TestMetadata("kt56227.kt") + public void testKt56227() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/callableReferences/kt56227.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inference/capturedTypes") + @TestDataPath("$PROJECT_ROOT") + public class CapturedTypes { + @Test + public void testAllFilesPresentInCapturedTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/capturedTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("approximateBeforeFixation.kt") + public void testApproximateBeforeFixation() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/approximateBeforeFixation.kt"); + } + + @Test + @TestMetadata("approximateContravariantCapturedTypes.kt") + public void testApproximateContravariantCapturedTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/approximateContravariantCapturedTypes.kt"); + } + + @Test + @TestMetadata("avoidCreatingUselessCapturedTypes.kt") + public void testAvoidCreatingUselessCapturedTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/avoidCreatingUselessCapturedTypes.kt"); + } + + @Test + @TestMetadata("cannotCaptureInProjection.kt") + public void testCannotCaptureInProjection() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/cannotCaptureInProjection.kt"); + } + + @Test + @TestMetadata("captureForNullableTypes.kt") + public void testCaptureForNullableTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/captureForNullableTypes.kt"); + } + + @Test + @TestMetadata("captureForPlatformTypes.kt") + public void testCaptureForPlatformTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/captureForPlatformTypes.kt"); + } + + @Test + @TestMetadata("captureFromNullableTypeVariable.kt") + public void testCaptureFromNullableTypeVariable() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/captureFromNullableTypeVariable.kt"); + } + + @Test + @TestMetadata("captureFromSubtyping.kt") + public void testCaptureFromSubtyping() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/captureFromSubtyping.kt"); + } + + @Test + @TestMetadata("captureFromTypeParameterUpperBound.kt") + public void testCaptureFromTypeParameterUpperBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/captureFromTypeParameterUpperBound.kt"); + } + + @Test + @TestMetadata("captureTypeOnlyOnTopLevel.kt") + public void testCaptureTypeOnlyOnTopLevel() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/captureTypeOnlyOnTopLevel.kt"); + } + + @Test + @TestMetadata("capturedFlexibleIntersectionTypesWithDifferentBounds.kt") + public void testCapturedFlexibleIntersectionTypesWithDifferentBounds() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/capturedFlexibleIntersectionTypesWithDifferentBounds.kt"); + } + + @Test + @TestMetadata("capturedFlexibleIntersectionTypesWithDifferentConstructors.kt") + public void testCapturedFlexibleIntersectionTypesWithDifferentConstructors() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/capturedFlexibleIntersectionTypesWithDifferentConstructors.kt"); + } + + @Test + @TestMetadata("capturedType.kt") + public void testCapturedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/capturedType.kt"); + } + + @Test + @TestMetadata("capturedTypeAndApproximation.kt") + public void testCapturedTypeAndApproximation() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/capturedTypeAndApproximation.kt"); + } + + @Test + @TestMetadata("capturedTypeSubstitutedIntoOppositeProjection.kt") + public void testCapturedTypeSubstitutedIntoOppositeProjection() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/capturedTypeSubstitutedIntoOppositeProjection.kt"); + } + + @Test + @TestMetadata("capturedTypeWithInnerTypealias.kt") + public void testCapturedTypeWithInnerTypealias() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/capturedTypeWithInnerTypealias.kt"); + } + + @Test + @TestMetadata("capturedTypeWithTypeVariableSubtyping.kt") + public void testCapturedTypeWithTypeVariableSubtyping() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/capturedTypeWithTypeVariableSubtyping.kt"); + } + + @Test + @TestMetadata("capturedTypesSubstitutionIntoAbbreviation.kt") + public void testCapturedTypesSubstitutionIntoAbbreviation() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/capturedTypesSubstitutionIntoAbbreviation.kt"); + } + + @Test + @TestMetadata("capturingFromArgumentOfFlexibleType.kt") + public void testCapturingFromArgumentOfFlexibleType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/capturingFromArgumentOfFlexibleType.kt"); + } + + @Test + @TestMetadata("differentCapturedTypes.kt") + public void testDifferentCapturedTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/differentCapturedTypes.kt"); + } + + @Test + @TestMetadata("dontCheckNewCapturedTypeSpecificChecksForOldOnes.kt") + public void testDontCheckNewCapturedTypeSpecificChecksForOldOnes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/dontCheckNewCapturedTypeSpecificChecksForOldOnes.kt"); + } + + @Test + @TestMetadata("expectedTypeMismatchWithInVariance.kt") + public void testExpectedTypeMismatchWithInVariance() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/expectedTypeMismatchWithInVariance.kt"); + } + + @Test + @TestMetadata("invokeCallWithCapturedReceiver.kt") + public void testInvokeCallWithCapturedReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/invokeCallWithCapturedReceiver.kt"); + } + + @Test + @TestMetadata("kt25302.kt") + public void testKt25302() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/kt25302.kt"); + } + + @Test + @TestMetadata("kt2570.kt") + public void testKt2570() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/kt2570.kt"); + } + + @Test + @TestMetadata("kt2872.kt") + public void testKt2872() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/kt2872.kt"); + } + + @Test + @TestMetadata("kt46727.kt") + public void testKt46727() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/kt46727.kt"); + } + + @Test + @TestMetadata("kt46727Warnings.kt") + public void testKt46727Warnings() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/kt46727Warnings.kt"); + } + + @Test + @TestMetadata("kt49101.kt") + public void testKt49101() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/kt49101.kt"); + } + + @Test + @TestMetadata("kt52782.kt") + public void testKt52782() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/kt52782.kt"); + } + + @Test + @TestMetadata("memberScopeOfCaptured.kt") + public void testMemberScopeOfCaptured() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/memberScopeOfCaptured.kt"); + } + + @Test + @TestMetadata("noCaptureTypeErrorForNonTopLevel.kt") + public void testNoCaptureTypeErrorForNonTopLevel() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/noCaptureTypeErrorForNonTopLevel.kt"); + } + + @Test + @TestMetadata("notApproximateWhenCopyDescriptors.kt") + public void testNotApproximateWhenCopyDescriptors() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/notApproximateWhenCopyDescriptors.kt"); + } + + @Test + @TestMetadata("nullableCaptruredTypeAgainstNullableVariable.kt") + public void testNullableCaptruredTypeAgainstNullableVariable() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/nullableCaptruredTypeAgainstNullableVariable.kt"); + } + + @Test + @TestMetadata("nullableCaptruredTypeAgainstNullableVariableWithDisabledComplatibilityFlag.kt") + public void testNullableCaptruredTypeAgainstNullableVariableWithDisabledComplatibilityFlag() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/nullableCaptruredTypeAgainstNullableVariableWithDisabledComplatibilityFlag.kt"); + } + + @Test + @TestMetadata("overApproximationForInCaptured.kt") + public void testOverApproximationForInCaptured() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/overApproximationForInCaptured.kt"); + } + + @Test + @TestMetadata("overApproximationForOutCaptured.kt") + public void testOverApproximationForOutCaptured() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/overApproximationForOutCaptured.kt"); + } + + @Test + @TestMetadata("propagateNullailityOnSupertypesWhenCaptureTypes.kt") + public void testPropagateNullailityOnSupertypesWhenCaptureTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/propagateNullailityOnSupertypesWhenCaptureTypes.kt"); + } + + @Test + @TestMetadata("starProjectionRegression.kt") + public void testStarProjectionRegression() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/starProjectionRegression.kt"); + } + + @Test + @TestMetadata("substituteCapturedTypesWithTypeVariables.kt") + public void testSubstituteCapturedTypesWithTypeVariables() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/substituteCapturedTypesWithTypeVariables.kt"); + } + + @Test + @TestMetadata("topLevelCapturingInsideReturnType.kt") + public void testTopLevelCapturingInsideReturnType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/topLevelCapturingInsideReturnType.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inference/coercionToUnit") + @TestDataPath("$PROJECT_ROOT") + public class CoercionToUnit { + @Test + @TestMetadata("afterBareReturn.kt") + public void testAfterBareReturn() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/afterBareReturn.kt"); + } + + @Test + public void testAllFilesPresentInCoercionToUnit() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/coercionToUnit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("coercionToUnitForIfAsLastExpressionInLambda.kt") + public void testCoercionToUnitForIfAsLastExpressionInLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionToUnitForIfAsLastExpressionInLambda.kt"); + } + + @Test + @TestMetadata("coercionToUnitForLastLambdaInLambda.kt") + public void testCoercionToUnitForLastLambdaInLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionToUnitForLastLambdaInLambda.kt"); + } + + @Test + @TestMetadata("coercionToUnitReference.kt") + public void testCoercionToUnitReference() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionToUnitReference.kt"); + } + + @Test + @TestMetadata("coercionToUnitWithNothingType.kt") + public void testCoercionToUnitWithNothingType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionToUnitWithNothingType.kt"); + } + + @Test + @TestMetadata("coercionWithExpectedType.kt") + public void testCoercionWithExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExpectedType.kt"); + } + + @Test + @TestMetadata("coercionWithExpectedTypeAndBound.kt") + public void testCoercionWithExpectedTypeAndBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExpectedTypeAndBound.kt"); + } + + @Test + @TestMetadata("coercionWithExplicitTypeArgument.kt") + public void testCoercionWithExplicitTypeArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExplicitTypeArgument.kt"); + } + + @Test + @TestMetadata("coercionWithoutExpectedType.kt") + public void testCoercionWithoutExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithoutExpectedType.kt"); + } + + @Test + @TestMetadata("coerctionToUnitForATypeWithUpperBound.kt") + public void testCoerctionToUnitForATypeWithUpperBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coerctionToUnitForATypeWithUpperBound.kt"); + } + + @Test + @TestMetadata("coersionWithAnonymousFunctionsAndUnresolved.kt") + public void testCoersionWithAnonymousFunctionsAndUnresolved() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coersionWithAnonymousFunctionsAndUnresolved.kt"); + } + + @Test + @TestMetadata("indirectCoercionWithExpectedType.kt") + public void testIndirectCoercionWithExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/indirectCoercionWithExpectedType.kt"); + } + + @Test + @TestMetadata("kt30242.kt") + public void testKt30242() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/kt30242.kt"); + } + + @Test + @TestMetadata("lambdaWithNullableUnitInElvis.kt") + public void testLambdaWithNullableUnitInElvis() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/lambdaWithNullableUnitInElvis.kt"); + } + + @Test + @TestMetadata("nestedLambda.kt") + public void testNestedLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/nestedLambda.kt"); + } + + @Test + @TestMetadata("noCoercion.kt") + public void testNoCoercion() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/noCoercion.kt"); + } + + @Test + @TestMetadata("nonPropagationOfCoercionToUnitInsideNestedLambda.kt") + public void testNonPropagationOfCoercionToUnitInsideNestedLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/nonPropagationOfCoercionToUnitInsideNestedLambda.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inference/commonSystem") + @TestDataPath("$PROJECT_ROOT") + public class CommonSystem { + @Test + public void testAllFilesPresentInCommonSystem() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/commonSystem"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("boundOnNullableVariable.kt") + public void testBoundOnNullableVariable() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/boundOnNullableVariable.kt"); + } + + @Test + @TestMetadata("castToSubtype.kt") + public void testCastToSubtype() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/castToSubtype.kt"); + } + + @Test + @TestMetadata("cstFromNullableChildAndNonParameterizedType.kt") + public void testCstFromNullableChildAndNonParameterizedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/cstFromNullableChildAndNonParameterizedType.kt"); + } + + @Test + @TestMetadata("cstWithTypeContainingNonFixedVariable.kt") + public void testCstWithTypeContainingNonFixedVariable() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/cstWithTypeContainingNonFixedVariable.kt"); + } + + @Test + @TestMetadata("dontCaptureTypeVariable.kt") + public void testDontCaptureTypeVariable() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/dontCaptureTypeVariable.kt"); + } + + @Test + @TestMetadata("exactOnElvis.kt") + public void testExactOnElvis() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/exactOnElvis.kt"); + } + + @Test + @TestMetadata("fixVariablesInRightOrder.kt") + public void testFixVariablesInRightOrder() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/fixVariablesInRightOrder.kt"); + } + + @Test + @TestMetadata("genericCandidateInGenericClass.kt") + public void testGenericCandidateInGenericClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/genericCandidateInGenericClass.kt"); + } + + @Test + @TestMetadata("iltInsideSeveralCalls.kt") + public void testIltInsideSeveralCalls() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/iltInsideSeveralCalls.kt"); + } + + @Test + @TestMetadata("inferenceWithUpperBoundsInLambda.kt") + public void testInferenceWithUpperBoundsInLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/inferenceWithUpperBoundsInLambda.kt"); + } + + @Test + @TestMetadata("kt30300.kt") + public void testKt30300() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/kt30300.kt"); + } + + @Test + @TestMetadata("kt31969.kt") + public void testKt31969() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/kt31969.kt"); + } + + @Test + @TestMetadata("kt32818.kt") + public void testKt32818() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/kt32818.kt"); + } + + @Test + @TestMetadata("kt33197.kt") + public void testKt33197() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/kt33197.kt"); + } + + @Test + @TestMetadata("kt3372toCollection.kt") + public void testKt3372toCollection() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/kt3372toCollection.kt"); + } + + @Test + @TestMetadata("lessSpecificTypeForArgumentCallWithExactAnnotation.kt") + public void testLessSpecificTypeForArgumentCallWithExactAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/lessSpecificTypeForArgumentCallWithExactAnnotation.kt"); + } + + @Test + @TestMetadata("lessSpecificTypeForArgumentCallWithExactAnnotation_ni.kt") + public void testLessSpecificTypeForArgumentCallWithExactAnnotation_ni() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/lessSpecificTypeForArgumentCallWithExactAnnotation_ni.kt"); + } + + @Test + @TestMetadata("manyArgumentsForVararg.kt") + public void testManyArgumentsForVararg() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/manyArgumentsForVararg.kt"); + } + + @Test + @TestMetadata("nestedLambdas.kt") + public void testNestedLambdas() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/nestedLambdas.kt"); + } + + @Test + @TestMetadata("nonFixedVariableFromBothBranches.kt") + public void testNonFixedVariableFromBothBranches() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/nonFixedVariableFromBothBranches.kt"); + } + + @Test + @TestMetadata("nonFixedVariableInsideFlexibleType.kt") + public void testNonFixedVariableInsideFlexibleType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/nonFixedVariableInsideFlexibleType.kt"); + } + + @Test + @TestMetadata("outProjectedTypeToOutProjected.kt") + public void testOutProjectedTypeToOutProjected() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/outProjectedTypeToOutProjected.kt"); + } + + @Test + @TestMetadata("postponedCompletionWithExactAnnotation.kt") + public void testPostponedCompletionWithExactAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/postponedCompletionWithExactAnnotation.kt"); + } + + @Test + @TestMetadata("postponedCompletionWithExactAnnotation_ni.kt") + public void testPostponedCompletionWithExactAnnotation_ni() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/postponedCompletionWithExactAnnotation_ni.kt"); + } + + @Test + @TestMetadata("selectFromTwoIncompatibleTypes.kt") + public void testSelectFromTwoIncompatibleTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/selectFromTwoIncompatibleTypes.kt"); + } + + @Test + @TestMetadata("selectIntegerValueTypeFromIf.kt") + public void testSelectIntegerValueTypeFromIf() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/selectIntegerValueTypeFromIf.kt"); + } + + @Test + @TestMetadata("theSameFunctionInArgs.kt") + public void testTheSameFunctionInArgs() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/commonSystem/theSameFunctionInArgs.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inference/completion") + @TestDataPath("$PROJECT_ROOT") + public class Completion { + @Test + public void testAllFilesPresentInCompletion() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/completion"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("anonymousFunction.kt") + public void testAnonymousFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/anonymousFunction.kt"); + } + + @Test + @TestMetadata("basic.kt") + public void testBasic() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/basic.kt"); + } + + @Test + @TestMetadata("definitelyNotNullType.kt") + public void testDefinitelyNotNullType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/definitelyNotNullType.kt"); + } + + @Test + @TestMetadata("equalityConstraintUpstairs.kt") + public void testEqualityConstraintUpstairs() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/equalityConstraintUpstairs.kt"); + } + + @Test + @TestMetadata("errorAfterCompletion.kt") + public void testErrorAfterCompletion() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/errorAfterCompletion.kt"); + } + + @Test + @TestMetadata("flexibleType.kt") + public void testFlexibleType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/flexibleType.kt"); + } + + @Test + @TestMetadata("inferLabeledElementTypeForLambdaInReturnInCatch.kt") + public void testInferLabeledElementTypeForLambdaInReturnInCatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/inferLabeledElementTypeForLambdaInReturnInCatch.kt"); + } + + @Test + @TestMetadata("intersectionType.kt") + public void testIntersectionType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/intersectionType.kt"); + } + + @Test + @TestMetadata("kt33166.kt") + public void testKt33166() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/kt33166.kt"); + } + + @Test + @TestMetadata("kt36233.kt") + public void testKt36233() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/kt36233.kt"); + } + + @Test + @TestMetadata("lambdaWithVariableAndNothing.kt") + public void testLambdaWithVariableAndNothing() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/lambdaWithVariableAndNothing.kt"); + } + + @Test + @TestMetadata("nestedVariance.kt") + public void testNestedVariance() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/nestedVariance.kt"); + } + + @Test + @TestMetadata("nothingFromNestedCall.kt") + public void testNothingFromNestedCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/nothingFromNestedCall.kt"); + } + + @Test + @TestMetadata("partialForIlt.kt") + public void testPartialForIlt() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/partialForIlt.kt"); + } + + @Test + @TestMetadata("partialForIltWithNothing.kt") + public void testPartialForIltWithNothing() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/partialForIltWithNothing.kt"); + } + + @Test + @TestMetadata("transitiveConstraint.kt") + public void testTransitiveConstraint() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/transitiveConstraint.kt"); + } + + @Test + @TestMetadata("withExact.kt") + public void testWithExact() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/withExact.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis") + @TestDataPath("$PROJECT_ROOT") + public class PostponedArgumentsAnalysis { + @Test + public void testAllFilesPresentInPostponedArgumentsAnalysis() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("basic.kt") + public void testBasic() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/basic.kt"); + } + + @Test + @TestMetadata("callableReferenceLambdaCombinationInsideCall.kt") + public void testCallableReferenceLambdaCombinationInsideCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/callableReferenceLambdaCombinationInsideCall.kt"); + } + + @Test + @TestMetadata("callableReferences.kt") + public void testCallableReferences() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/callableReferences.kt"); + } + + @Test + @TestMetadata("fixingVariableDuringAddingConstraintForFirstPosponedArgument.kt") + public void testFixingVariableDuringAddingConstraintForFirstPosponedArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/fixingVariableDuringAddingConstraintForFirstPosponedArgument.kt"); + } + + @Test + @TestMetadata("lackOfDeepIncorporation.kt") + public void testLackOfDeepIncorporation() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/lackOfDeepIncorporation.kt"); + } + + @Test + @TestMetadata("lambdasInTryCatch.kt") + public void testLambdasInTryCatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/lambdasInTryCatch.kt"); + } + + @Test + @TestMetadata("notInferableParameterOfAnonymousFunction.kt") + public void testNotInferableParameterOfAnonymousFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/notInferableParameterOfAnonymousFunction.kt"); + } + + @Test + @TestMetadata("takingExtensibilityFromDeclarationOfAnonymousFunction.kt") + public void testTakingExtensibilityFromDeclarationOfAnonymousFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/takingExtensibilityFromDeclarationOfAnonymousFunction.kt"); + } + + @Test + @TestMetadata("wrongVariableFixationOrder.kt") + public void testWrongVariableFixationOrder() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/wrongVariableFixationOrder.kt"); + } + + @Test + @TestMetadata("wrongVariableFixationOrder2.kt") + public void testWrongVariableFixationOrder2() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/wrongVariableFixationOrder2.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inference/constraints") + @TestDataPath("$PROJECT_ROOT") + public class Constraints { + @Test + public void testAllFilesPresentInConstraints() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/constraints"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("approximationWithDefNotNullInInvPositionDuringInference.kt") + public void testApproximationWithDefNotNullInInvPositionDuringInference() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/approximationWithDefNotNullInInvPositionDuringInference.kt"); + } + + @Test + @TestMetadata("complexDependencyWihtoutProperConstraints.kt") + public void testComplexDependencyWihtoutProperConstraints() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/complexDependencyWihtoutProperConstraints.kt"); + } + + @Test + @TestMetadata("constraintFromVariantTypeWithNestedProjection.kt") + public void testConstraintFromVariantTypeWithNestedProjection() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/constraintFromVariantTypeWithNestedProjection.kt"); + } + + @Test + @TestMetadata("constraintOnFunctionLiteral.kt") + public void testConstraintOnFunctionLiteral() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/constraintOnFunctionLiteral.kt"); + } + + @Test + @TestMetadata("definitelyNotNullTypeInArguments.kt") + public void testDefinitelyNotNullTypeInArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/definitelyNotNullTypeInArguments.kt"); + } + + @Test + @TestMetadata("definitelyNotNullTypeInReturnPosition.kt") + public void testDefinitelyNotNullTypeInReturnPosition() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/definitelyNotNullTypeInReturnPosition.kt"); + } + + @Test + @TestMetadata("definitelyNotNullTypeInvariantPosition.kt") + public void testDefinitelyNotNullTypeInvariantPosition() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/definitelyNotNullTypeInvariantPosition.kt"); + } + + @Test + @TestMetadata("earlyCompletionForCalls.kt") + public void testEarlyCompletionForCalls() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/earlyCompletionForCalls.kt"); + } + + @Test + @TestMetadata("equalityConstraintOnNullableType.kt") + public void testEqualityConstraintOnNullableType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/equalityConstraintOnNullableType.kt"); + } + + @Test + @TestMetadata("errorUpperBoundConstraint.kt") + public void testErrorUpperBoundConstraint() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/errorUpperBoundConstraint.kt"); + } + + @Test + @TestMetadata("fixTypeVariableWithNothingConstraintEarlierThanComplexVariable.kt") + public void testFixTypeVariableWithNothingConstraintEarlierThanComplexVariable() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/fixTypeVariableWithNothingConstraintEarlierThanComplexVariable.kt"); + } + + @Test + @TestMetadata("ignoreConstraintFromImplicitInNothing.kt") + public void testIgnoreConstraintFromImplicitInNothing() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/ignoreConstraintFromImplicitInNothing.kt"); + } + + @Test + @TestMetadata("inferTypeFromCapturedStarProjection.kt") + public void testInferTypeFromCapturedStarProjection() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/inferTypeFromCapturedStarProjection.kt"); + } + + @Test + @TestMetadata("kt6320.kt") + public void testKt6320() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/kt6320.kt"); + } + + @Test + @TestMetadata("kt7351ConstraintFromUnitExpectedType.kt") + public void testKt7351ConstraintFromUnitExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/kt7351ConstraintFromUnitExpectedType.kt"); + } + + @Test + @TestMetadata("kt7433.kt") + public void testKt7433() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/kt7433.kt"); + } + + @Test + @TestMetadata("kt8879.kt") + public void testKt8879() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/kt8879.kt"); + } + + @Test + @TestMetadata("manyConstraintsDueToFlexibleRawTypes.kt") + public void testManyConstraintsDueToFlexibleRawTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToFlexibleRawTypes.kt"); + } + + @Test + @TestMetadata("manyConstraintsDueToRecursiveFlexibleTypesWithWildcards.kt") + public void testManyConstraintsDueToRecursiveFlexibleTypesWithWildcards() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToRecursiveFlexibleTypesWithWildcards.kt"); + } + + @Test + @TestMetadata("notNullConstraintOnNullableType.kt") + public void testNotNullConstraintOnNullableType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/notNullConstraintOnNullableType.kt"); + } + + @Test + @TestMetadata("operationsOnIntegerValueTypes.kt") + public void testOperationsOnIntegerValueTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/operationsOnIntegerValueTypes.kt"); + } + + @Test + @TestMetadata("recursiveJavaTypeWithStarProjection.kt") + public void testRecursiveJavaTypeWithStarProjection() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/recursiveJavaTypeWithStarProjection.kt"); + } + + @Test + @TestMetadata("remainConstraintContainingTypeWithoutProjection.kt") + public void testRemainConstraintContainingTypeWithoutProjection() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/remainConstraintContainingTypeWithoutProjection.kt"); + } + + @Test + @TestMetadata("returnLambdaFromLambda.kt") + public void testReturnLambdaFromLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/returnLambdaFromLambda.kt"); + } + + @Test + @TestMetadata("subtypeConstraintOnNullableType.kt") + public void testSubtypeConstraintOnNullableType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/subtypeConstraintOnNullableType.kt"); + } + + @Test + @TestMetadata("supertypeConstraintOnNullableType.kt") + public void testSupertypeConstraintOnNullableType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/supertypeConstraintOnNullableType.kt"); + } + + @Test + @TestMetadata("wrongApproximationWithDefNotNullTypesAndDelegates.kt") + public void testWrongApproximationWithDefNotNullTypesAndDelegates() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/constraints/wrongApproximationWithDefNotNullTypesAndDelegates.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes") + @TestDataPath("$PROJECT_ROOT") + public class EmptyIntersectionTypes { + @Test + public void testAllFilesPresentInEmptyIntersectionTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("compatibilityResolveWhenVariableHasComplexIntersectionType.kt") + public void testCompatibilityResolveWhenVariableHasComplexIntersectionType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/compatibilityResolveWhenVariableHasComplexIntersectionType.kt"); + } + + @Test + @TestMetadata("contravariance.kt") + public void testContravariance() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/contravariance.kt"); + } + + @Test + @TestMetadata("covariance.kt") + public void testCovariance() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/covariance.kt"); + } + + @Test + @TestMetadata("kt45461.kt") + public void testKt45461() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461.kt"); + } + + @Test + @TestMetadata("kt45461_10.kt") + public void testKt45461_10() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_10.kt"); + } + + @Test + @TestMetadata("kt45461_11.kt") + public void testKt45461_11() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_11.kt"); + } + + @Test + @TestMetadata("kt45461_12.kt") + public void testKt45461_12() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_12.kt"); + } + + @Test + @TestMetadata("kt45461_13.kt") + public void testKt45461_13() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_13.kt"); + } + + @Test + @TestMetadata("kt45461_14.kt") + public void testKt45461_14() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_14.kt"); + } + + @Test + @TestMetadata("kt45461_15.kt") + public void testKt45461_15() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_15.kt"); + } + + @Test + @TestMetadata("kt45461_16.kt") + public void testKt45461_16() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_16.kt"); + } + + @Test + @TestMetadata("kt45461_17.kt") + public void testKt45461_17() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_17.kt"); + } + + @Test + @TestMetadata("kt45461_18.kt") + public void testKt45461_18() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_18.kt"); + } + + @Test + @TestMetadata("kt45461_19.kt") + public void testKt45461_19() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_19.kt"); + } + + @Test + @TestMetadata("kt45461_2.kt") + public void testKt45461_2() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_2.kt"); + } + + @Test + @TestMetadata("kt45461_20.kt") + public void testKt45461_20() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_20.kt"); + } + + @Test + @TestMetadata("kt45461_21.kt") + public void testKt45461_21() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_21.kt"); + } + + @Test + @TestMetadata("kt45461_22.kt") + public void testKt45461_22() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_22.kt"); + } + + @Test + @TestMetadata("kt45461_23.kt") + public void testKt45461_23() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_23.kt"); + } + + @Test + @TestMetadata("kt45461_24.kt") + public void testKt45461_24() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_24.kt"); + } + + @Test + @TestMetadata("kt45461_25.kt") + public void testKt45461_25() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_25.kt"); + } + + @Test + @TestMetadata("kt45461_26.kt") + public void testKt45461_26() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_26.kt"); + } + + @Test + @TestMetadata("kt45461_27.kt") + public void testKt45461_27() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_27.kt"); + } + + @Test + @TestMetadata("kt45461_28.kt") + public void testKt45461_28() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_28.kt"); + } + + @Test + @TestMetadata("kt45461_29.kt") + public void testKt45461_29() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_29.kt"); + } + + @Test + @TestMetadata("kt45461_3.kt") + public void testKt45461_3() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_3.kt"); + } + + @Test + @TestMetadata("kt45461_30.kt") + public void testKt45461_30() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_30.kt"); + } + + @Test + @TestMetadata("kt45461_31.kt") + public void testKt45461_31() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_31.kt"); + } + + @Test + @TestMetadata("kt45461_32.kt") + public void testKt45461_32() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_32.kt"); + } + + @Test + @TestMetadata("kt45461_33.kt") + public void testKt45461_33() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_33.kt"); + } + + @Test + @TestMetadata("kt45461_34.kt") + public void testKt45461_34() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_34.kt"); + } + + @Test + @TestMetadata("kt45461_35.kt") + public void testKt45461_35() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_35.kt"); + } + + @Test + @TestMetadata("kt45461_35_Enabled.kt") + public void testKt45461_35_Enabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_35_Enabled.kt"); + } + + @Test + @TestMetadata("kt45461_4.kt") + public void testKt45461_4() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_4.kt"); + } + + @Test + @TestMetadata("kt45461_5.kt") + public void testKt45461_5() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_5.kt"); + } + + @Test + @TestMetadata("kt45461_6.kt") + public void testKt45461_6() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_6.kt"); + } + + @Test + @TestMetadata("kt45461_7.kt") + public void testKt45461_7() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_7.kt"); + } + + @Test + @TestMetadata("kt45461_8.kt") + public void testKt45461_8() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_8.kt"); + } + + @Test + @TestMetadata("kt45461_9.kt") + public void testKt45461_9() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt45461_9.kt"); + } + + @Test + @TestMetadata("kt48765.kt") + public void testKt48765() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt48765.kt"); + } + + @Test + @TestMetadata("kt48935.kt") + public void testKt48935() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt48935.kt"); + } + + @Test + @TestMetadata("kt48935_2.kt") + public void testKt48935_2() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt48935_2.kt"); + } + + @Test + @TestMetadata("kt48935_3.kt") + public void testKt48935_3() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt48935_3.kt"); + } + + @Test + @TestMetadata("kt48935_4.kt") + public void testKt48935_4() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt48935_4.kt"); + } + + @Test + @TestMetadata("kt48935_5.kt") + public void testKt48935_5() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt48935_5.kt"); + } + + @Test + @TestMetadata("kt48935_6.kt") + public void testKt48935_6() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt48935_6.kt"); + } + + @Test + @TestMetadata("kt48987.kt") + public void testKt48987() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt48987.kt"); + } + + @Test + @TestMetadata("kt49661.kt") + public void testKt49661() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt49661.kt"); + } + + @Test + @TestMetadata("kt51016.kt") + public void testKt51016() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt51016.kt"); + } + + @Test + @TestMetadata("kt52364.kt") + public void testKt52364() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt52364.kt"); + } + + @Test + @TestMetadata("kt52393.kt") + public void testKt52393() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt52393.kt"); + } + + @Test + @TestMetadata("kt52431.kt") + public void testKt52431() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt52431.kt"); + } + + @Test + @TestMetadata("kt54411.kt") + public void testKt54411() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt54411.kt"); + } + + @Test + @TestMetadata("nullableEmptyIntersection.kt") + public void testNullableEmptyIntersection() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/nullableEmptyIntersection.kt"); + } + + @Test + @TestMetadata("recursiveTypeParameters.kt") + public void testRecursiveTypeParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/recursiveTypeParameters.kt"); + } + + @Test + @TestMetadata("selectFromCovariantAndContravariantTypes.kt") + public void testSelectFromCovariantAndContravariantTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/selectFromCovariantAndContravariantTypes.kt"); + } + + @Test + @TestMetadata("substitutingSuperTypes.kt") + public void testSubstitutingSuperTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/substitutingSuperTypes.kt"); + } + + @Test + @TestMetadata("substitutingSuperTypes2.kt") + public void testSubstitutingSuperTypes2() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/substitutingSuperTypes2.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inference/forks") + @TestDataPath("$PROJECT_ROOT") + public class Forks { + @Test + public void testAllFilesPresentInForks() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/forks"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("nestedCallVariableFixation.kt") + public void testNestedCallVariableFixation() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/forks/nestedCallVariableFixation.kt"); + } + + @Test + @TestMetadata("nestedCallVariableFixationSimple.kt") + public void testNestedCallVariableFixationSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/forks/nestedCallVariableFixationSimple.kt"); + } + + @Test + @TestMetadata("overloadResolutionByLambdaReturnTypeAndExpectedType.kt") + public void testOverloadResolutionByLambdaReturnTypeAndExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/forks/overloadResolutionByLambdaReturnTypeAndExpectedType.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inference/nestedCalls") + @TestDataPath("$PROJECT_ROOT") + public class NestedCalls { + @Test + public void testAllFilesPresentInNestedCalls() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/nestedCalls"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("arrayAccess.kt") + public void testArrayAccess() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/arrayAccess.kt"); + } + + @Test + @TestMetadata("binaryExpressions.kt") + public void testBinaryExpressions() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/binaryExpressions.kt"); + } + + @Test + @TestMetadata("checkTypesForQualifiedProperties.kt") + public void testCheckTypesForQualifiedProperties() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/checkTypesForQualifiedProperties.kt"); + } + + @Test + @TestMetadata("completeNestedCallsForArraySetExpression.kt") + public void testCompleteNestedCallsForArraySetExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/completeNestedCallsForArraySetExpression.kt"); + } + + @Test + @TestMetadata("completeNestedCallsInference.kt") + public void testCompleteNestedCallsInference() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/completeNestedCallsInference.kt"); + } + + @Test + @TestMetadata("completeNestedForVariableAsFunctionCall.kt") + public void testCompleteNestedForVariableAsFunctionCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/completeNestedForVariableAsFunctionCall.kt"); + } + + @Test + @TestMetadata("externalTypeParameter.kt") + public void testExternalTypeParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/externalTypeParameter.kt"); + } + + @Test + @TestMetadata("inferenceForNestedBinaryCall.kt") + public void testInferenceForNestedBinaryCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/inferenceForNestedBinaryCall.kt"); + } + + @Test + @TestMetadata("kt3395.kt") + public void testKt3395() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/kt3395.kt"); + } + + @Test + @TestMetadata("kt3461checkTypes.kt") + public void testKt3461checkTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/kt3461checkTypes.kt"); + } + + @Test + @TestMetadata("makeNullableIfSafeCall.kt") + public void testMakeNullableIfSafeCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/makeNullableIfSafeCall.kt"); + } + + @Test + @TestMetadata("nontrivialCallExpression.kt") + public void testNontrivialCallExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/nontrivialCallExpression.kt"); + } + + @Test + @TestMetadata("preferArgumentToNullability.kt") + public void testPreferArgumentToNullability() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/preferArgumentToNullability.kt"); + } + + @Test + @TestMetadata("preferNothingToBound.kt") + public void testPreferNothingToBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/preferNothingToBound.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inference/nothingType") + @TestDataPath("$PROJECT_ROOT") + public class NothingType { + @Test + public void testAllFilesPresentInNothingType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/nothingType"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("complexDependancyOnVariableWithTrivialConstraint.kt") + public void testComplexDependancyOnVariableWithTrivialConstraint() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/complexDependancyOnVariableWithTrivialConstraint.kt"); + } + + @Test + @TestMetadata("discriminateNothingForReifiedParameter.kt") + public void testDiscriminateNothingForReifiedParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/discriminateNothingForReifiedParameter.kt"); + } + + @Test + @TestMetadata("discriminatedNothingAndSmartCast.kt") + public void testDiscriminatedNothingAndSmartCast() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/discriminatedNothingAndSmartCast.kt"); + } + + @Test + @TestMetadata("discriminatedNothingInsideComplexNestedCall.kt") + public void testDiscriminatedNothingInsideComplexNestedCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/discriminatedNothingInsideComplexNestedCall.kt"); + } + + @Test + @TestMetadata("generateConstraintWithInnerNothingType.kt") + public void testGenerateConstraintWithInnerNothingType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/generateConstraintWithInnerNothingType.kt"); + } + + @Test + @TestMetadata("genericOverride.kt") + public void testGenericOverride() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/genericOverride.kt"); + } + + @Test + @TestMetadata("implicitInferenceTToFlexibleNothing.kt") + public void testImplicitInferenceTToFlexibleNothing() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/implicitInferenceTToFlexibleNothing.kt"); + } + + @Test + @TestMetadata("implicitNothingConstraintFromReturn.kt") + public void testImplicitNothingConstraintFromReturn() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/implicitNothingConstraintFromReturn.kt"); + } + + @Test + @TestMetadata("inferArgumentToNothingFromNullConstant.kt") + public void testInferArgumentToNothingFromNullConstant() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/inferArgumentToNothingFromNullConstant.kt"); + } + + @Test + @TestMetadata("inferenceWithRecursiveGenericsAndNothing.kt") + public void testInferenceWithRecursiveGenericsAndNothing() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/inferenceWithRecursiveGenericsAndNothing.kt"); + } + + @Test + @TestMetadata("kt24490.kt") + public void testKt24490() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/kt24490.kt"); + } + + @Test + @TestMetadata("kt32051.kt") + public void testKt32051() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/kt32051.kt"); + } + + @Test + @TestMetadata("kt32081.kt") + public void testKt32081() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/kt32081.kt"); + } + + @Test + @TestMetadata("kt32207.kt") + public void testKt32207() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/kt32207.kt"); + } + + @Test + @TestMetadata("kt32388.kt") + public void testKt32388() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/kt32388.kt"); + } + + @Test + @TestMetadata("kt34335.kt") + public void testKt34335() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/kt34335.kt"); + } + + @Test + @TestMetadata("kt56448.kt") + public void testKt56448() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/kt56448.kt"); + } + + @Test + @TestMetadata("lambdaNothingAndExpectedType.kt") + public void testLambdaNothingAndExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/lambdaNothingAndExpectedType.kt"); + } + + @Test + @TestMetadata("nestedLambdaInferenceWithIncorporationOfVariables.kt") + public void testNestedLambdaInferenceWithIncorporationOfVariables() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/nestedLambdaInferenceWithIncorporationOfVariables.kt"); + } + + @Test + @TestMetadata("notEnoughInformationAndNothing.kt") + public void testNotEnoughInformationAndNothing() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/notEnoughInformationAndNothing.kt"); + } + + @Test + @TestMetadata("notEnoughInformationFromNullabilityConstraint.kt") + public void testNotEnoughInformationFromNullabilityConstraint() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/notEnoughInformationFromNullabilityConstraint.kt"); + } + + @Test + @TestMetadata("nothingWithCallableReference.kt") + public void testNothingWithCallableReference() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/nothingWithCallableReference.kt"); + } + + @Test + @TestMetadata("nullableExpectedTypeFromVariable.kt") + public void testNullableExpectedTypeFromVariable() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/nullableExpectedTypeFromVariable.kt"); + } + + @Test + @TestMetadata("platformNothingAsUsefulConstraint.kt") + public void testPlatformNothingAsUsefulConstraint() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/platformNothingAsUsefulConstraint.kt"); + } + + @Test + @TestMetadata("reifiedParameterWithRecursiveBound.kt") + public void testReifiedParameterWithRecursiveBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/reifiedParameterWithRecursiveBound.kt"); + } + + @Test + @TestMetadata("reportImplicitNothingOnlyForOwnTypeParameters.kt") + public void testReportImplicitNothingOnlyForOwnTypeParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/reportImplicitNothingOnlyForOwnTypeParameters.kt"); + } + + @Test + @TestMetadata("selectWithNull.kt") + public void testSelectWithNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/selectWithNull.kt"); + } + + @Test + @TestMetadata("specialCallWithMaterializeAndExpectedType.kt") + public void testSpecialCallWithMaterializeAndExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/nothingType/specialCallWithMaterializeAndExpectedType.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inference/publicApproximation") + @TestDataPath("$PROJECT_ROOT") + public class PublicApproximation { + @Test + public void testAllFilesPresentInPublicApproximation() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/publicApproximation"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("approximatedIntersectionMorePreciseThanBound.kt") + public void testApproximatedIntersectionMorePreciseThanBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/publicApproximation/approximatedIntersectionMorePreciseThanBound.kt"); + } + + @Test + @TestMetadata("chainedLambdas.kt") + public void testChainedLambdas() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/publicApproximation/chainedLambdas.kt"); + } + + @Test + @TestMetadata("declarationTypes.kt") + public void testDeclarationTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/publicApproximation/declarationTypes.kt"); + } + + @Test + @TestMetadata("intersectionAfterSmartCastInLambdaReturn.kt") + public void testIntersectionAfterSmartCastInLambdaReturn() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/publicApproximation/intersectionAfterSmartCastInLambdaReturn.kt"); + } + + @Test + @TestMetadata("intersectionAlternative.kt") + public void testIntersectionAlternative() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/publicApproximation/intersectionAlternative.kt"); + } + + @Test + @TestMetadata("intersectionLocations.kt") + public void testIntersectionLocations() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/publicApproximation/intersectionLocations.kt"); + } + + @Test + @TestMetadata("lambdaReturnArgumentCall.kt") + public void testLambdaReturnArgumentCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/publicApproximation/lambdaReturnArgumentCall.kt"); + } + + @Test + @TestMetadata("lambdaReturnTypeApproximation.kt") + public void testLambdaReturnTypeApproximation() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/publicApproximation/lambdaReturnTypeApproximation.kt"); + } + + @Test + @TestMetadata("nonTrivialVariance.kt") + public void testNonTrivialVariance() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/publicApproximation/nonTrivialVariance.kt"); + } + + @Test + @TestMetadata("parameterInBound.kt") + public void testParameterInBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/publicApproximation/parameterInBound.kt"); + } + + @Test + @TestMetadata("projections.kt") + public void testProjections() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/publicApproximation/projections.kt"); + } + + @Test + @TestMetadata("smartCastInLambdaReturnAfterIntersection.kt") + public void testSmartCastInLambdaReturnAfterIntersection() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/publicApproximation/smartCastInLambdaReturnAfterIntersection.kt"); + } + + @Test + @TestMetadata("twoIntersections.kt") + public void testTwoIntersections() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/publicApproximation/twoIntersections.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inference/recursiveCalls") + @TestDataPath("$PROJECT_ROOT") + public class RecursiveCalls { + @Test + public void testAllFilesPresentInRecursiveCalls() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/recursiveCalls"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("kt23531.kt") + public void testKt23531() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/recursiveCalls/kt23531.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inference/recursiveLocalFuns") + @TestDataPath("$PROJECT_ROOT") + public class RecursiveLocalFuns { + @Test + public void testAllFilesPresentInRecursiveLocalFuns() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/recursiveLocalFuns"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("localFactorial.kt") + public void testLocalFactorial() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/localFactorial.kt"); + } + + @Test + @TestMetadata("recursiveFun.kt") + public void testRecursiveFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/recursiveFun.kt"); + } + + @Test + @TestMetadata("recursiveLambda.kt") + public void testRecursiveLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/recursiveLambda.kt"); + } + + @Test + @TestMetadata("selfCall.kt") + public void testSelfCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/selfCall.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inference/recursiveTypes") + @TestDataPath("$PROJECT_ROOT") + public class RecursiveTypes { + @Test + public void testAllFilesPresentInRecursiveTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/recursiveTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("multirecursion.kt") + public void testMultirecursion() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/multirecursion.kt"); + } + + @Test + @TestMetadata("recursiveInIn.kt") + public void testRecursiveInIn() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/recursiveInIn.kt"); + } + + @Test + @TestMetadata("recursiveInInv.kt") + public void testRecursiveInInv() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/recursiveInInv.kt"); + } + + @Test + @TestMetadata("recursiveInOut.kt") + public void testRecursiveInOut() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/recursiveInOut.kt"); + } + + @Test + @TestMetadata("recursiveInvIn.kt") + public void testRecursiveInvIn() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/recursiveInvIn.kt"); + } + + @Test + @TestMetadata("recursiveInvOut.kt") + public void testRecursiveInvOut() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/recursiveInvOut.kt"); + } + + @Test + @TestMetadata("recursiveOutIn.kt") + public void testRecursiveOutIn() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/recursiveOutIn.kt"); + } + + @Test + @TestMetadata("recursiveOutInv.kt") + public void testRecursiveOutInv() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/recursiveOutInv.kt"); + } + + @Test + @TestMetadata("recursiveOutOut.kt") + public void testRecursiveOutOut() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/recursiveOutOut.kt"); + } + + @Test + @TestMetadata("recursiveTypeWithNonStarResult.kt") + public void testRecursiveTypeWithNonStarResult() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/recursiveTypeWithNonStarResult.kt"); + } + + @Test + @TestMetadata("recursiveTypes.kt") + public void testRecursiveTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/recursiveTypes.kt"); + } + + @Test + @TestMetadata("twoTypeConstructors.kt") + public void testTwoTypeConstructors() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/twoTypeConstructors.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inference/recursiveTypes/selfTypes") + @TestDataPath("$PROJECT_ROOT") + public class SelfTypes { + @Test + public void testAllFilesPresentInSelfTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/recursiveTypes/selfTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inference/recursiveTypes/selfTypes/disabledInferenceOnSelfTypes") + @TestDataPath("$PROJECT_ROOT") + public class DisabledInferenceOnSelfTypes { + @Test + public void testAllFilesPresentInDisabledInferenceOnSelfTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/recursiveTypes/selfTypes/disabledInferenceOnSelfTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("basicInferenceForImplicitSelfType.kt") + public void testBasicInferenceForImplicitSelfType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/selfTypes/disabledInferenceOnSelfTypes/basicInferenceForImplicitSelfType.kt"); + } + + @Test + @TestMetadata("recursiveTypeWithTwoTypeParams.kt") + public void testRecursiveTypeWithTwoTypeParams() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/selfTypes/disabledInferenceOnSelfTypes/recursiveTypeWithTwoTypeParams.kt"); + } + + @Test + @TestMetadata("writerAppenderExampleRecursive.kt") + public void testWriterAppenderExampleRecursive() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/selfTypes/disabledInferenceOnSelfTypes/writerAppenderExampleRecursive.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inference/recursiveTypes/selfTypes/enabledInferenceOnSelfTypes") + @TestDataPath("$PROJECT_ROOT") + public class EnabledInferenceOnSelfTypes { + @Test + public void testAllFilesPresentInEnabledInferenceOnSelfTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/recursiveTypes/selfTypes/enabledInferenceOnSelfTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("basicInferenceForImplicitSelfType.kt") + public void testBasicInferenceForImplicitSelfType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/selfTypes/enabledInferenceOnSelfTypes/basicInferenceForImplicitSelfType.kt"); + } + + @Test + @TestMetadata("recursiveTypeWithTwoTypeParams.kt") + public void testRecursiveTypeWithTwoTypeParams() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/selfTypes/enabledInferenceOnSelfTypes/recursiveTypeWithTwoTypeParams.kt"); + } + + @Test + @TestMetadata("writerAppenderExampleRecursive.kt") + public void testWriterAppenderExampleRecursive() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/selfTypes/enabledInferenceOnSelfTypes/writerAppenderExampleRecursive.kt"); + } + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inference/regressions") + @TestDataPath("$PROJECT_ROOT") + public class Regressions { + @Test + public void testAllFilesPresentInRegressions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/regressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("compareBy.kt") + public void testCompareBy() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/compareBy.kt"); + } + + @Test + @TestMetadata("kt1029.kt") + public void testKt1029() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt1029.kt"); + } + + @Test + @TestMetadata("kt1031.kt") + public void testKt1031() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt1031.kt"); + } + + @Test + @TestMetadata("kt1127.kt") + public void testKt1127() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt1127.kt"); + } + + @Test + @TestMetadata("kt1145.kt") + public void testKt1145() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt1145.kt"); + } + + @Test + @TestMetadata("kt1358.kt") + public void testKt1358() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt1358.kt"); + } + + @Test + @TestMetadata("kt1410.kt") + public void testKt1410() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt1410.kt"); + } + + @Test + @TestMetadata("kt1718.kt") + public void testKt1718() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt1718.kt"); + } + + @Test + @TestMetadata("kt1944.kt") + public void testKt1944() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt1944.kt"); + } + + @Test + @TestMetadata("kt2057.kt") + public void testKt2057() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2057.kt"); + } + + @Test + @TestMetadata("kt2179.kt") + public void testKt2179() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2179.kt"); + } + + @Test + @TestMetadata("kt2200.kt") + public void testKt2200() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2200.kt"); + } + + @Test + @TestMetadata("kt2283.kt") + public void testKt2283() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2283.kt"); + } + + @Test + @TestMetadata("kt2286.kt") + public void testKt2286() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2286.kt"); + } + + @Test + @TestMetadata("kt2294.kt") + public void testKt2294() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2294.kt"); + } + + @Test + @TestMetadata("kt2320.kt") + public void testKt2320() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2320.kt"); + } + + @Test + @TestMetadata("kt2324.kt") + public void testKt2324() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2324.kt"); + } + + @Test + @TestMetadata("kt2407.kt") + public void testKt2407() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2407.kt"); + } + + @Test + @TestMetadata("kt2445.kt") + public void testKt2445() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2445.kt"); + } + + @Test + @TestMetadata("kt2459.kt") + public void testKt2459() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2459.kt"); + } + + @Test + @TestMetadata("kt2484.kt") + public void testKt2484() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2484.kt"); + } + + @Test + @TestMetadata("kt2505.kt") + public void testKt2505() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2505.kt"); + } + + @Test + @TestMetadata("kt2514.kt") + public void testKt2514() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2514.kt"); + } + + @Test + @TestMetadata("kt2588.kt") + public void testKt2588() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2588.kt"); + } + + @Test + @TestMetadata("kt2741.kt") + public void testKt2741() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2741.kt"); + } + + @Test + @TestMetadata("kt2754.kt") + public void testKt2754() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2754.kt"); + } + + @Test + @TestMetadata("kt2838.kt") + public void testKt2838() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2838.kt"); + } + + @Test + @TestMetadata("kt2841.kt") + public void testKt2841() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2841.kt"); + } + + @Test + @TestMetadata("kt2841_it.kt") + public void testKt2841_it() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2841_it.kt"); + } + + @Test + @TestMetadata("kt2841_it_this.kt") + public void testKt2841_it_this() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2841_it_this.kt"); + } + + @Test + @TestMetadata("kt2841_this.kt") + public void testKt2841_this() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2841_this.kt"); + } + + @Test + @TestMetadata("kt2842.kt") + public void testKt2842() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2842.kt"); + } + + @Test + @TestMetadata("kt2883.kt") + public void testKt2883() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2883.kt"); + } + + @Test + @TestMetadata("kt3007.kt") + public void testKt3007() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt3007.kt"); + } + + @Test + @TestMetadata("kt3038.kt") + public void testKt3038() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt3038.kt"); + } + + @Test + @TestMetadata("kt3150.kt") + public void testKt3150() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt3150.kt"); + } + + @Test + @TestMetadata("kt3174.kt") + public void testKt3174() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt3174.kt"); + } + + @Test + @TestMetadata("kt32106.kt") + public void testKt32106() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt32106.kt"); + } + + @Test + @TestMetadata("kt32250.kt") + public void testKt32250() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt32250.kt"); + } + + @Test + @TestMetadata("kt32862_both.kt") + public void testKt32862_both() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt32862_both.kt"); + } + + @Test + @TestMetadata("kt32862_none.kt") + public void testKt32862_none() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt32862_none.kt"); + } + + @Test + @TestMetadata("kt3301.kt") + public void testKt3301() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt3301.kt"); + } + + @Test + @TestMetadata("kt3344.kt") + public void testKt3344() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt3344.kt"); + } + + @Test + @TestMetadata("kt33629.kt") + public void testKt33629() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt33629.kt"); + } + + @Test + @TestMetadata("kt34029.kt") + public void testKt34029() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt34029.kt"); + } + + @Test + @TestMetadata("kt34282.kt") + public void testKt34282() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt34282.kt"); + } + + @Test + @TestMetadata("kt3496.kt") + public void testKt3496() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt3496.kt"); + } + + @Test + @TestMetadata("kt3496_2.kt") + public void testKt3496_2() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt3496_2.kt"); + } + + @Test + @TestMetadata("kt3559.kt") + public void testKt3559() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt3559.kt"); + } + + @Test + @TestMetadata("kt35844.kt") + public void testKt35844() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt35844.kt"); + } + + @Test + @TestMetadata("kt35943.kt") + public void testKt35943() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt35943.kt"); + } + + @Test + @TestMetadata("kt36342.kt") + public void testKt36342() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt36342.kt"); + } + + @Test + @TestMetadata("kt36342_2.kt") + public void testKt36342_2() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt36342_2.kt"); + } + + @Test + @TestMetadata("kt37043.kt") + public void testKt37043() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt37043.kt"); + } + + @Test + @TestMetadata("kt37043_2.kt") + public void testKt37043_2() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt37043_2.kt"); + } + + @Test + @TestMetadata("kt37419.kt") + public void testKt37419() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt37419.kt"); + } + + @Test + @TestMetadata("kt37650.kt") + public void testKt37650() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt37650.kt"); + } + + @Test + @TestMetadata("kt38549.kt") + public void testKt38549() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt38549.kt"); + } + + @Test + @TestMetadata("kt38691.kt") + public void testKt38691() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt38691.kt"); + } + + @Test + @TestMetadata("kt41386.kt") + public void testKt41386() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt41386.kt"); + } + + @Test + @TestMetadata("kt41394.kt") + public void testKt41394() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt41394.kt"); + } + + @Test + @TestMetadata("kt4420.kt") + public void testKt4420() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt4420.kt"); + } + + @Test + @TestMetadata("kt44440.kt") + public void testKt44440() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt44440.kt"); + } + + @Test + @TestMetadata("kt47941.kt") + public void testKt47941() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt47941.kt"); + } + + @Test + @TestMetadata("kt702.kt") + public void testKt702() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt702.kt"); + } + + @Test + @TestMetadata("kt731.kt") + public void testKt731() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt731.kt"); + } + + @Test + @TestMetadata("kt742.kt") + public void testKt742() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt742.kt"); + } + + @Test + @TestMetadata("kt8132.kt") + public void testKt8132() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt8132.kt"); + } + + @Test + @TestMetadata("kt832.kt") + public void testKt832() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt832.kt"); + } + + @Test + @TestMetadata("kt943.kt") + public void testKt943() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt943.kt"); + } + + @Test + @TestMetadata("kt9461.kt") + public void testKt9461() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt9461.kt"); + } + + @Test + @TestMetadata("kt948.kt") + public void testKt948() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/kt948.kt"); + } + + @Test + @TestMetadata("noRecursionOnCallingPureKotlinFunctionAsSyntheticJavaAccessor.kt") + public void testNoRecursionOnCallingPureKotlinFunctionAsSyntheticJavaAccessor() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/regressions/noRecursionOnCallingPureKotlinFunctionAsSyntheticJavaAccessor.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inference/reportingImprovements") + @TestDataPath("$PROJECT_ROOT") + public class ReportingImprovements { + @Test + public void testAllFilesPresentInReportingImprovements() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/reportingImprovements"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("cannotInferParameterTypeWithInference.kt") + public void testCannotInferParameterTypeWithInference() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/reportingImprovements/cannotInferParameterTypeWithInference.kt"); + } + + @Test + @TestMetadata("ErrorTypeAsGenericParameter.kt") + public void testErrorTypeAsGenericParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/reportingImprovements/ErrorTypeAsGenericParameter.kt"); + } + + @Test + @TestMetadata("FunctionPlaceholder.kt") + public void testFunctionPlaceholder() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.kt"); + } + + @Test + @TestMetadata("inferTypeFromUnresolvedArgument.kt") + public void testInferTypeFromUnresolvedArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/reportingImprovements/inferTypeFromUnresolvedArgument.kt"); + } + + @Test + @TestMetadata("kt42620.kt") + public void testKt42620() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/reportingImprovements/kt42620.kt"); + } + + @Test + @TestMetadata("NoAmbiguityForDifferentFunctionTypes.kt") + public void testNoAmbiguityForDifferentFunctionTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/reportingImprovements/NoAmbiguityForDifferentFunctionTypes.kt"); + } + + @Test + @TestMetadata("reportUnresolvedReferenceWrongReceiverForManyCandidates.kt") + public void testReportUnresolvedReferenceWrongReceiverForManyCandidates() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/reportingImprovements/reportUnresolvedReferenceWrongReceiverForManyCandidates.kt"); + } + + @Test + @TestMetadata("subtypeForInvariantWithErrorGenerics.kt") + public void testSubtypeForInvariantWithErrorGenerics() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/reportingImprovements/subtypeForInvariantWithErrorGenerics.kt"); + } + + @Test + @TestMetadata("typeInferenceFailedOnComponentN.kt") + public void testTypeInferenceFailedOnComponentN() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnComponentN.kt"); + } + + @Test + @TestMetadata("typeInferenceFailedOnIteratorCall.kt") + public void testTypeInferenceFailedOnIteratorCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnIteratorCall.kt"); + } + + @Test + @TestMetadata("wrongArgumentExtensionFunction.kt") + public void testWrongArgumentExtensionFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/reportingImprovements/wrongArgumentExtensionFunction.kt"); + } + + @Test + @TestMetadata("wrongArgumentPassedToLocalExtensionFunction.kt") + public void testWrongArgumentPassedToLocalExtensionFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/reportingImprovements/wrongArgumentPassedToLocalExtensionFunction.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inference/substitutions") + @TestDataPath("$PROJECT_ROOT") + public class Substitutions { + @Test + public void testAllFilesPresentInSubstitutions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/substitutions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("delegationAndInference.kt") + public void testDelegationAndInference() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/substitutions/delegationAndInference.kt"); + } + + @Test + @TestMetadata("hideFlexibleLocalTypeInPublicPosition.kt") + public void testHideFlexibleLocalTypeInPublicPosition() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/substitutions/hideFlexibleLocalTypeInPublicPosition.kt"); + } + + @Test + @TestMetadata("hideFlexibleLocalTypeInPublicPosition_before.kt") + public void testHideFlexibleLocalTypeInPublicPosition_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/substitutions/hideFlexibleLocalTypeInPublicPosition_before.kt"); + } + + @Test + @TestMetadata("hideLocalTypeForReturnTypeOfSingleExpressionFunction.kt") + public void testHideLocalTypeForReturnTypeOfSingleExpressionFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/substitutions/hideLocalTypeForReturnTypeOfSingleExpressionFunction.kt"); + } + + @Test + @TestMetadata("hideNullableLocalTypeInPublicPosition.kt") + public void testHideNullableLocalTypeInPublicPosition() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/substitutions/hideNullableLocalTypeInPublicPosition.kt"); + } + + @Test + @TestMetadata("hideNullableLocalTypeInPublicPosition_before.kt") + public void testHideNullableLocalTypeInPublicPosition_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/substitutions/hideNullableLocalTypeInPublicPosition_before.kt"); + } + + @Test + @TestMetadata("kt32189returnTypeWithTypealiasSubtitution.kt") + public void testKt32189returnTypeWithTypealiasSubtitution() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/substitutions/kt32189returnTypeWithTypealiasSubtitution.kt"); + } + + @Test + @TestMetadata("kt6081SubstituteIntoClassCorrectly.kt") + public void testKt6081SubstituteIntoClassCorrectly() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/substitutions/kt6081SubstituteIntoClassCorrectly.kt"); + } + + @Test + @TestMetadata("simpleSubstitutionCheckTypeArgumentsNotTypeParameters.kt") + public void testSimpleSubstitutionCheckTypeArgumentsNotTypeParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/substitutions/simpleSubstitutionCheckTypeArgumentsNotTypeParameters.kt"); + } + + @Test + @TestMetadata("substitutionIntoAnonymousClass.kt") + public void testSubstitutionIntoAnonymousClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/substitutions/substitutionIntoAnonymousClass.kt"); + } + + @Test + @TestMetadata("substitutionIntoInnerClass.kt") + public void testSubstitutionIntoInnerClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/substitutions/substitutionIntoInnerClass.kt"); + } + + @Test + @TestMetadata("substitutionOfTypeEnhancement.kt") + public void testSubstitutionOfTypeEnhancement() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/substitutions/substitutionOfTypeEnhancement.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inference/upperBounds") + @TestDataPath("$PROJECT_ROOT") + public class UpperBounds { + @Test + public void testAllFilesPresentInUpperBounds() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/upperBounds"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("conflictingSubstitutionsFromUpperBound.kt") + public void testConflictingSubstitutionsFromUpperBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/upperBounds/conflictingSubstitutionsFromUpperBound.kt"); + } + + @Test + @TestMetadata("doNotInferFromBoundsOnly.kt") + public void testDoNotInferFromBoundsOnly() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/upperBounds/doNotInferFromBoundsOnly.kt"); + } + + @Test + @TestMetadata("flexibilityInCommonSuperTypeCalculation.kt") + public void testFlexibilityInCommonSuperTypeCalculation() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/upperBounds/flexibilityInCommonSuperTypeCalculation.kt"); + } + + @Test + @TestMetadata("flexibilityInCommonSuperTypeCalculation.ni.kt") + public void testFlexibilityInCommonSuperTypeCalculation_ni() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/upperBounds/flexibilityInCommonSuperTypeCalculation.ni.kt"); + } + + @Test + @TestMetadata("inferringVariableByMaterializeAndUpperBound.kt") + public void testInferringVariableByMaterializeAndUpperBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/upperBounds/inferringVariableByMaterializeAndUpperBound.kt"); + } + + @Test + @TestMetadata("intersectUpperBounds.kt") + public void testIntersectUpperBounds() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/upperBounds/intersectUpperBounds.kt"); + } + + @Test + @TestMetadata("kt2856.kt") + public void testKt2856() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/upperBounds/kt2856.kt"); + } + + @Test + @TestMetadata("nonNullUpperBound.kt") + public void testNonNullUpperBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/upperBounds/nonNullUpperBound.kt"); + } + + @Test + @TestMetadata("typeParameterAsUpperBound.kt") + public void testTypeParameterAsUpperBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/upperBounds/typeParameterAsUpperBound.kt"); + } + + @Test + @TestMetadata("useBoundsIfUnknownParameters.kt") + public void testUseBoundsIfUnknownParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsIfUnknownParameters.kt"); + } + + @Test + @TestMetadata("useBoundsToInferTypeParamsSimple.kt") + public void testUseBoundsToInferTypeParamsSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsToInferTypeParamsSimple.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/infos") + @TestDataPath("$PROJECT_ROOT") + public class Infos { + @Test + public void testAllFilesPresentInInfos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/infos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("PropertiesWithBackingFields.kt") + public void testPropertiesWithBackingFields() throws Exception { + runTest("compiler/testData/diagnostics/tests/infos/PropertiesWithBackingFields.kt"); + } + + @Test + @TestMetadata("SmartCasts.kt") + public void testSmartCasts() throws Exception { + runTest("compiler/testData/diagnostics/tests/infos/SmartCasts.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inline") + @TestDataPath("$PROJECT_ROOT") + public class Inline { + @Test + public void testAllFilesPresentInInline() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("anonymousObjects.kt") + public void testAnonymousObjects() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/anonymousObjects.kt"); + } + + @Test + @TestMetadata("approximateReturnedAnonymousObjects.kt") + public void testApproximateReturnedAnonymousObjects() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/approximateReturnedAnonymousObjects.kt"); + } + + @Test + @TestMetadata("assignment.kt") + public void testAssignment() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/assignment.kt"); + } + + @Test + @TestMetadata("capture.kt") + public void testCapture() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/capture.kt"); + } + + @Test + @TestMetadata("constructor.kt") + public void testConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/constructor.kt"); + } + + @Test + @TestMetadata("default.kt") + public void testDefault() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/default.kt"); + } + + @Test + @TestMetadata("defaultLambdaInlineSuspend.kt") + public void testDefaultLambdaInlineSuspend() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/defaultLambdaInlineSuspend.kt"); + } + + @Test + @TestMetadata("defaultLambdaInlining.kt") + public void testDefaultLambdaInlining() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/defaultLambdaInlining.kt"); + } + + @Test + @TestMetadata("extensionOnFunction.kt") + public void testExtensionOnFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/extensionOnFunction.kt"); + } + + @Test + @TestMetadata("forbidExtensionCallsOnInlineFunctionalParameters_after.kt") + public void testForbidExtensionCallsOnInlineFunctionalParameters_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/forbidExtensionCallsOnInlineFunctionalParameters_after.kt"); + } + + @Test + @TestMetadata("forbidExtensionCallsOnInlineFunctionalParameters_before.kt") + public void testForbidExtensionCallsOnInlineFunctionalParameters_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/forbidExtensionCallsOnInlineFunctionalParameters_before.kt"); + } + + @Test + @TestMetadata("fromInlineToNoInline.kt") + public void testFromInlineToNoInline() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/fromInlineToNoInline.kt"); + } + + @Test + @TestMetadata("functions.kt") + public void testFunctions() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/functions.kt"); + } + + @Test + @TestMetadata("inlineLambdaInDefaultInlineParameter.kt") + public void testInlineLambdaInDefaultInlineParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/inlineLambdaInDefaultInlineParameter.kt"); + } + + @Test + @TestMetadata("inlineReified.kt") + public void testInlineReified() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/inlineReified.kt"); + } + + @Test + @TestMetadata("inlinedReturnInBranch.kt") + public void testInlinedReturnInBranch() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/inlinedReturnInBranch.kt"); + } + + @Test + @TestMetadata("invoke.kt") + public void testInvoke() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/invoke.kt"); + } + + @Test + @TestMetadata("isCheck.kt") + public void testIsCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/isCheck.kt"); + } + + @Test + @TestMetadata("kt15410.kt") + public void testKt15410() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/kt15410.kt"); + } + + @Test + @TestMetadata("kt19679.kt") + public void testKt19679() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/kt19679.kt"); + } + + @Test + @TestMetadata("kt21177.kt") + public void testKt21177() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/kt21177.kt"); + } + + @Test + @TestMetadata("kt21177Warning.kt") + public void testKt21177Warning() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/kt21177Warning.kt"); + } + + @Test + @TestMetadata("kt4869.kt") + public void testKt4869() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/kt4869.kt"); + } + + @Test + @TestMetadata("labeled.kt") + public void testLabeled() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/labeled.kt"); + } + + @Test + @TestMetadata("lambdaCast.kt") + public void testLambdaCast() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/lambdaCast.kt"); + } + + @Test + @TestMetadata("localFun.kt") + public void testLocalFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/localFun.kt"); + } + + @Test + @TestMetadata("messagesForUnsupportedInInline.kt") + public void testMessagesForUnsupportedInInline() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/messagesForUnsupportedInInline.kt"); + } + + @Test + @TestMetadata("nonVirtualMembersWithInline.kt") + public void testNonVirtualMembersWithInline() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonVirtualMembersWithInline.kt"); + } + + @Test + @TestMetadata("nothingToInline.kt") + public void testNothingToInline() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nothingToInline.kt"); + } + + @Test + @TestMetadata("nullabilityOperations.kt") + public void testNullabilityOperations() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nullabilityOperations.kt"); + } + + @Test + @TestMetadata("nullableFunction.kt") + public void testNullableFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nullableFunction.kt"); + } + + @Test + @TestMetadata("overrideWithInline.kt") + public void testOverrideWithInline() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/overrideWithInline.kt"); + } + + @Test + @TestMetadata("parenthesized.kt") + public void testParenthesized() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/parenthesized.kt"); + } + + @Test + @TestMetadata("privateClass.kt") + public void testPrivateClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/privateClass.kt"); + } + + @Test + @TestMetadata("propagation.kt") + public void testPropagation() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/propagation.kt"); + } + + @Test + @TestMetadata("protectedCallDepecation.kt") + public void testProtectedCallDepecation() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/protectedCallDepecation.kt"); + } + + @Test + @TestMetadata("protectedCallError.kt") + public void testProtectedCallError() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/protectedCallError.kt"); + } + + @Test + @TestMetadata("publishedApi.kt") + public void testPublishedApi() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/publishedApi.kt"); + } + + @Test + @TestMetadata("recursion.kt") + public void testRecursion() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/recursion.kt"); + } + + @Test + @TestMetadata("recursiveTypeInPrivateInlineFunction.kt") + public void testRecursiveTypeInPrivateInlineFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/recursiveTypeInPrivateInlineFunction.kt"); + } + + @Test + @TestMetadata("returnedAnonymousObjects.kt") + public void testReturnedAnonymousObjects() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/returnedAnonymousObjects.kt"); + } + + @Test + @TestMetadata("returnedAnonymousObjects_2.kt") + public void testReturnedAnonymousObjects_2() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/returnedAnonymousObjects_2.kt"); + } + + @Test + @TestMetadata("returns.kt") + public void testReturns() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/returns.kt"); + } + + @Test + @TestMetadata("sam.kt") + public void testSam() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/sam.kt"); + } + + @Test + @TestMetadata("stringTemplate.kt") + public void testStringTemplate() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/stringTemplate.kt"); + } + + @Test + @TestMetadata("superCall.kt") + public void testSuperCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/superCall.kt"); + } + + @Test + @TestMetadata("superCallDepecation.kt") + public void testSuperCallDepecation() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/superCallDepecation.kt"); + } + + @Test + @TestMetadata("superCallDepecationWarning.kt") + public void testSuperCallDepecationWarning() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/superCallDepecationWarning.kt"); + } + + @Test + @TestMetadata("superCallFromMultipleSubclasses.kt") + public void testSuperCallFromMultipleSubclasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/superCallFromMultipleSubclasses.kt"); + } + + @Test + @TestMetadata("superProperty.kt") + public void testSuperProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/superProperty.kt"); + } + + @Test + @TestMetadata("valueClasses.kt") + public void testValueClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/valueClasses.kt"); + } + + @Test + @TestMetadata("vararg.kt") + public void testVararg() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/vararg.kt"); + } + + @Test + @TestMetadata("virtualMemberInEnum.kt") + public void testVirtualMemberInEnum() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/virtualMemberInEnum.kt"); + } + + @Test + @TestMetadata("when.kt") + public void testWhen() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/when.kt"); + } + + @Test + @TestMetadata("wrongUsage.kt") + public void testWrongUsage() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/wrongUsage.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inline/binaryExpressions") + @TestDataPath("$PROJECT_ROOT") + public class BinaryExpressions { + @Test + public void testAllFilesPresentInBinaryExpressions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/binaryExpressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("andOr.kt") + public void testAndOr() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/binaryExpressions/andOr.kt"); + } + + @Test + @TestMetadata("arrayAccess.kt") + public void testArrayAccess() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/binaryExpressions/arrayAccess.kt"); + } + + @Test + @TestMetadata("assignment.kt") + public void testAssignment() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/binaryExpressions/assignment.kt"); + } + + @Test + @TestMetadata("comparison.kt") + public void testComparison() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/binaryExpressions/comparison.kt"); + } + + @Test + @TestMetadata("componentAccess.kt") + public void testComponentAccess() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/binaryExpressions/componentAccess.kt"); + } + + @Test + @TestMetadata("contains.kt") + public void testContains() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/binaryExpressions/contains.kt"); + } + + @Test + @TestMetadata("mathOperations.kt") + public void testMathOperations() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/binaryExpressions/mathOperations.kt"); + } + + @Test + @TestMetadata("rangeTo.kt") + public void testRangeTo() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/binaryExpressions/rangeTo.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inline/nonLocalReturns") + @TestDataPath("$PROJECT_ROOT") + public class NonLocalReturns { + @Test + public void testAllFilesPresentInNonLocalReturns() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("anonymousObjects.kt") + public void testAnonymousObjects() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/anonymousObjects.kt"); + } + + @Test + @TestMetadata("anonymousObjectsNested.kt") + public void testAnonymousObjectsNested() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/anonymousObjectsNested.kt"); + } + + @Test + @TestMetadata("explicitReturnType.kt") + public void testExplicitReturnType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/explicitReturnType.kt"); + } + + @Test + @TestMetadata("fromOnlyLocal.kt") + public void testFromOnlyLocal() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/fromOnlyLocal.kt"); + } + + @Test + @TestMetadata("inlineLambda.kt") + public void testInlineLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/inlineLambda.kt"); + } + + @Test + @TestMetadata("labeledReturn.kt") + public void testLabeledReturn() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/labeledReturn.kt"); + } + + @Test + @TestMetadata("lambdaAsGeneric.kt") + public void testLambdaAsGeneric() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaAsGeneric.kt"); + } + + @Test + @TestMetadata("lambdaAsNonFunction.kt") + public void testLambdaAsNonFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaAsNonFunction.kt"); + } + + @Test + @TestMetadata("lambdaWithGlobalReturnsInsideOnlyLocalOne.kt") + public void testLambdaWithGlobalReturnsInsideOnlyLocalOne() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaWithGlobalReturnsInsideOnlyLocalOne.kt"); + } + + @Test + @TestMetadata("localFun.kt") + public void testLocalFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/localFun.kt"); + } + + @Test + @TestMetadata("nestedNonLocals.kt") + public void testNestedNonLocals() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/nestedNonLocals.kt"); + } + + @Test + @TestMetadata("noInlineAnnotation.kt") + public void testNoInlineAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/noInlineAnnotation.kt"); + } + + @Test + @TestMetadata("noInlineLambda.kt") + public void testNoInlineLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/noInlineLambda.kt"); + } + + @Test + @TestMetadata("nonInlinedClass.kt") + public void testNonInlinedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/nonInlinedClass.kt"); + } + + @Test + @TestMetadata("onlyLocalReturnLambda.kt") + public void testOnlyLocalReturnLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/onlyLocalReturnLambda.kt"); + } + + @Test + @TestMetadata("onlyLocalReturnLambdaBinaryExpr.kt") + public void testOnlyLocalReturnLambdaBinaryExpr() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/onlyLocalReturnLambdaBinaryExpr.kt"); + } + + @Test + @TestMetadata("propertyAccessorsAndConstructor.kt") + public void testPropertyAccessorsAndConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/propertyAccessorsAndConstructor.kt"); + } + + @Test + @TestMetadata("toOnlyLocal.kt") + public void testToOnlyLocal() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/toOnlyLocal.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inline/nonPublicMember") + @TestDataPath("$PROJECT_ROOT") + public class NonPublicMember { + @Test + public void testAllFilesPresentInNonPublicMember() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/nonPublicMember"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("inNonPublicClass.kt") + public void testInNonPublicClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonPublicMember/inNonPublicClass.kt"); + } + + @Test + @TestMetadata("inNonPublicInnerClass.kt") + public void testInNonPublicInnerClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonPublicMember/inNonPublicInnerClass.kt"); + } + + @Test + @TestMetadata("inPackage.kt") + public void testInPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonPublicMember/inPackage.kt"); + } + + @Test + @TestMetadata("inPublicClass.kt") + public void testInPublicClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonPublicMember/inPublicClass.kt"); + } + + @Test + @TestMetadata("kt14887.kt") + public void testKt14887() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonPublicMember/kt14887.kt"); + } + + @Test + @TestMetadata("kt55179.kt") + public void testKt55179() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonPublicMember/kt55179.kt"); + } + + @Test + @TestMetadata("localClass.kt") + public void testLocalClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonPublicMember/localClass.kt"); + } + + @Test + @TestMetadata("localClass2.kt") + public void testLocalClass2() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonPublicMember/localClass2.kt"); + } + + @Test + @TestMetadata("localFun.kt") + public void testLocalFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonPublicMember/localFun.kt"); + } + + @Test + @TestMetadata("publishedApi.kt") + public void testPublishedApi() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/nonPublicMember/publishedApi.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inline/property") + @TestDataPath("$PROJECT_ROOT") + public class Property { + @Test + public void testAllFilesPresentInProperty() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/property"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("invoke.kt") + public void testInvoke() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/property/invoke.kt"); + } + + @Test + @TestMetadata("propertyWithBackingField.kt") + public void testPropertyWithBackingField() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/property/propertyWithBackingField.kt"); + } + + @Test + @TestMetadata("unsupportedConstruction.kt") + public void testUnsupportedConstruction() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/property/unsupportedConstruction.kt"); + } + + @Test + @TestMetadata("virtualProperty.kt") + public void testVirtualProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/property/virtualProperty.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inline/regressions") + @TestDataPath("$PROJECT_ROOT") + public class Regressions { + @Test + public void testAllFilesPresentInRegressions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/regressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("kt4341.kt") + public void testKt4341() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/regressions/kt4341.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inline/unaryExpressions") + @TestDataPath("$PROJECT_ROOT") + public class UnaryExpressions { + @Test + public void testAllFilesPresentInUnaryExpressions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/unaryExpressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("mathOperation.kt") + public void testMathOperation() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/unaryExpressions/mathOperation.kt"); + } + + @Test + @TestMetadata("notOnCall.kt") + public void testNotOnCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/unaryExpressions/notOnCall.kt"); + } + + @Test + @TestMetadata("notOperation.kt") + public void testNotOperation() throws Exception { + runTest("compiler/testData/diagnostics/tests/inline/unaryExpressions/notOperation.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inlineClasses") + @TestDataPath("$PROJECT_ROOT") + public class InlineClasses { + @Test + public void testAllFilesPresentInInlineClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("basicInlineClassDeclaration.kt") + public void testBasicInlineClassDeclaration() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/basicInlineClassDeclaration.kt"); + } + + @Test + @TestMetadata("basicInlineClassDeclarationDisabled.kt") + public void testBasicInlineClassDeclarationDisabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/basicInlineClassDeclarationDisabled.kt"); + } + + @Test + @TestMetadata("changingNullabilityOfOrdinaryClassIsBinaryCompatibleChange.kt") + public void testChangingNullabilityOfOrdinaryClassIsBinaryCompatibleChange() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/changingNullabilityOfOrdinaryClassIsBinaryCompatibleChange.kt"); + } + + @Test + @TestMetadata("constructorsJvmSignaturesClash.kt") + public void testConstructorsJvmSignaturesClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/constructorsJvmSignaturesClash.kt"); + } + + @Test + @TestMetadata("delegatedPropertyInInlineClass.kt") + public void testDelegatedPropertyInInlineClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/delegatedPropertyInInlineClass.kt"); + } + + @Test + @TestMetadata("functionsJvmSignaturesClash.kt") + public void testFunctionsJvmSignaturesClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/functionsJvmSignaturesClash.kt"); + } + + @Test + @TestMetadata("functionsJvmSignaturesConflictOnInheritance.kt") + public void testFunctionsJvmSignaturesConflictOnInheritance() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/functionsJvmSignaturesConflictOnInheritance.kt"); + } + + @Test + @TestMetadata("genericInlineClass.kt") + public void testGenericInlineClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/genericInlineClass.kt"); + } + + @Test + @TestMetadata("identityComparisonWithInlineClasses.kt") + public void testIdentityComparisonWithInlineClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/identityComparisonWithInlineClasses.kt"); + } + + @Test + @TestMetadata("inefficientEqualsOverridingInInlineClass.kt") + public void testInefficientEqualsOverridingInInlineClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/inefficientEqualsOverridingInInlineClass.kt"); + } + + @Test + @TestMetadata("inlineClassCanImplementInterfaceByDelegation.kt") + public void testInlineClassCanImplementInterfaceByDelegation() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/inlineClassCanImplementInterfaceByDelegation.kt"); + } + + @Test + @TestMetadata("inlineClassCanOnlyImplementInterfaces.kt") + public void testInlineClassCanOnlyImplementInterfaces() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/inlineClassCanOnlyImplementInterfaces.kt"); + } + + @Test + @TestMetadata("inlineClassCannotImplementInterfaceByDelegation.kt") + public void testInlineClassCannotImplementInterfaceByDelegation() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/inlineClassCannotImplementInterfaceByDelegation.kt"); + } + + @Test + @TestMetadata("inlineClassConstructorParameterWithDefaultValue.kt") + public void testInlineClassConstructorParameterWithDefaultValue() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/inlineClassConstructorParameterWithDefaultValue.kt"); + } + + @Test + @TestMetadata("inlineClassDeclarationCheck.kt") + public void testInlineClassDeclarationCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/inlineClassDeclarationCheck.kt"); + } + + @Test + @TestMetadata("inlineClassDeprecated.kt") + public void testInlineClassDeprecated() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/inlineClassDeprecated.kt"); + } + + @Test + @TestMetadata("inlineClassImplementsCollection.kt") + public void testInlineClassImplementsCollection() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/inlineClassImplementsCollection.kt"); + } + + @Test + @TestMetadata("inlineClassWithForbiddenUnderlyingType.kt") + public void testInlineClassWithForbiddenUnderlyingType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/inlineClassWithForbiddenUnderlyingType.kt"); + } + + @Test + @TestMetadata("inlineClassesInsideAnnotations.kt") + public void testInlineClassesInsideAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/inlineClassesInsideAnnotations.kt"); + } + + @Test + @TestMetadata("innerClassInsideInlineClass.kt") + public void testInnerClassInsideInlineClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/innerClassInsideInlineClass.kt"); + } + + @Test + @TestMetadata("lateinitInlineClassesOff.kt") + public void testLateinitInlineClassesOff() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/lateinitInlineClassesOff.kt"); + } + + @Test + @TestMetadata("lateinitInlineClassesOn.kt") + public void testLateinitInlineClassesOn() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/lateinitInlineClassesOn.kt"); + } + + @Test + @TestMetadata("presenceOfInitializerBlockInsideInlineClass.kt") + public void testPresenceOfInitializerBlockInsideInlineClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/presenceOfInitializerBlockInsideInlineClass.kt"); + } + + @Test + @TestMetadata("presenceOfPublicPrimaryConstructorForInlineClass.kt") + public void testPresenceOfPublicPrimaryConstructorForInlineClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/presenceOfPublicPrimaryConstructorForInlineClass.kt"); + } + + @Test + @TestMetadata("propertiesWithBackingFieldsInsideInlineClass.kt") + public void testPropertiesWithBackingFieldsInsideInlineClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/propertiesWithBackingFieldsInsideInlineClass.kt"); + } + + @Test + @TestMetadata("recursiveInlineClasses.kt") + public void testRecursiveInlineClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/recursiveInlineClasses.kt"); + } + + @Test + @TestMetadata("reifiedGenericUnderlyingType.kt") + public void testReifiedGenericUnderlyingType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/reifiedGenericUnderlyingType.kt"); + } + + @Test + @TestMetadata("reservedConstructorsBodyInKotlinPre19.kt") + public void testReservedConstructorsBodyInKotlinPre19() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/reservedConstructorsBodyInKotlinPre19.kt"); + } + + @Test + @TestMetadata("reservedMembersAndConstructsInsideInlineClass.kt") + public void testReservedMembersAndConstructsInsideInlineClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/reservedMembersAndConstructsInsideInlineClass.kt"); + } + + @Test + @TestMetadata("synchronizedForbidden.kt") + public void testSynchronizedForbidden() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/synchronizedForbidden.kt"); + } + + @Test + @TestMetadata("typedEqualsOperatorDeclarationCheck.kt") + public void testTypedEqualsOperatorDeclarationCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/typedEqualsOperatorDeclarationCheck.kt"); + } + + @Test + @TestMetadata("typedEqualsOperatorModifierInInlineClass.kt") + public void testTypedEqualsOperatorModifierInInlineClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/typedEqualsOperatorModifierInInlineClass.kt"); + } + + @Test + @TestMetadata("unsignedLiteralsWithoutArtifactOnClasspath.kt") + public void testUnsignedLiteralsWithoutArtifactOnClasspath() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/unsignedLiteralsWithoutArtifactOnClasspath.kt"); + } + + @Test + @TestMetadata("varargsOnParametersOfInlineClassType.kt") + public void testVarargsOnParametersOfInlineClassType() throws Exception { + runTest("compiler/testData/diagnostics/tests/inlineClasses/varargsOnParametersOfInlineClassType.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inner") + @TestDataPath("$PROJECT_ROOT") + public class Inner { + @Test + @TestMetadata("accessingToJavaNestedClass.kt") + public void testAccessingToJavaNestedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/accessingToJavaNestedClass.kt"); + } + + @Test + @TestMetadata("accessingToKotlinNestedClass.kt") + public void testAccessingToKotlinNestedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/accessingToKotlinNestedClass.kt"); + } + + @Test + public void testAllFilesPresentInInner() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inner"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("annotationInInnerClass.kt") + public void testAnnotationInInnerClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/annotationInInnerClass.kt"); + } + + @Test + @TestMetadata("classesInClassObjectHeader.kt") + public void testClassesInClassObjectHeader() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/classesInClassObjectHeader.kt"); + } + + @Test + @TestMetadata("constructorAccess.kt") + public void testConstructorAccess() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/constructorAccess.kt"); + } + + @Test + @TestMetadata("deepInnerClass.kt") + public void testDeepInnerClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/deepInnerClass.kt"); + } + + @Test + @TestMetadata("enumEntries.kt") + public void testEnumEntries() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/enumEntries.kt"); + } + + @Test + @TestMetadata("enumInInnerClass.kt") + public void testEnumInInnerClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/enumInInnerClass.kt"); + } + + @Test + @TestMetadata("extensionFun.kt") + public void testExtensionFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/extensionFun.kt"); + } + + @Test + @TestMetadata("extensionLambdaInsideNestedClass.kt") + public void testExtensionLambdaInsideNestedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/extensionLambdaInsideNestedClass.kt"); + } + + @Test + @TestMetadata("illegalModifier_lv12.kt") + public void testIllegalModifier_lv12() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/illegalModifier_lv12.kt"); + } + + @Test + @TestMetadata("innerClassInEnumEntryClassMemberResolve.kt") + public void testInnerClassInEnumEntryClassMemberResolve() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/innerClassInEnumEntryClassMemberResolve.kt"); + } + + @Test + @TestMetadata("innerClassInEnumEntryClass_lv12.kt") + public void testInnerClassInEnumEntryClass_lv12() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/innerClassInEnumEntryClass_lv12.kt"); + } + + @Test + @TestMetadata("innerClassInEnumEntryClass_lv13.kt") + public void testInnerClassInEnumEntryClass_lv13() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/innerClassInEnumEntryClass_lv13.kt"); + } + + @Test + @TestMetadata("InnerClassNameClash.kt") + public void testInnerClassNameClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/InnerClassNameClash.kt"); + } + + @Test + @TestMetadata("innerClassesInStaticParameters.kt") + public void testInnerClassesInStaticParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/innerClassesInStaticParameters.kt"); + } + + @Test + @TestMetadata("innerConstructorsFromQualifiers.kt") + public void testInnerConstructorsFromQualifiers() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/innerConstructorsFromQualifiers.kt"); + } + + @Test + @TestMetadata("innerConstructorsFromQualifiersWithIrrelevantCandidate.kt") + public void testInnerConstructorsFromQualifiersWithIrrelevantCandidate() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/innerConstructorsFromQualifiersWithIrrelevantCandidate.kt"); + } + + @Test + @TestMetadata("innerErrorForClassObjects.kt") + public void testInnerErrorForClassObjects() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/innerErrorForClassObjects.kt"); + } + + @Test + @TestMetadata("innerErrorForObjects.kt") + public void testInnerErrorForObjects() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/innerErrorForObjects.kt"); + } + + @Test + @TestMetadata("innerThisSuper.kt") + public void testInnerThisSuper() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/innerThisSuper.kt"); + } + + @Test + @TestMetadata("interfaceInInnerClass.kt") + public void testInterfaceInInnerClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/interfaceInInnerClass.kt"); + } + + @Test + @TestMetadata("kt5854.kt") + public void testKt5854() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/kt5854.kt"); + } + + @Test + @TestMetadata("kt6026.kt") + public void testKt6026() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/kt6026.kt"); + } + + @Test + @TestMetadata("localClass.kt") + public void testLocalClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/localClass.kt"); + } + + @Test + @TestMetadata("localClassInsideNested.kt") + public void testLocalClassInsideNested() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/localClassInsideNested.kt"); + } + + @Test + @TestMetadata("localThisSuper.kt") + public void testLocalThisSuper() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/localThisSuper.kt"); + } + + @Test + @TestMetadata("modality.kt") + public void testModality() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/modality.kt"); + } + + @Test + @TestMetadata("nestedClassAccessedViaInstanceReference.kt") + public void testNestedClassAccessedViaInstanceReference() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/nestedClassAccessedViaInstanceReference.kt"); + } + + @Test + @TestMetadata("nestedClassExtendsOuter.kt") + public void testNestedClassExtendsOuter() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/nestedClassExtendsOuter.kt"); + } + + @Test + @TestMetadata("nestedClassExtendsOuterGeneric.kt") + public void testNestedClassExtendsOuterGeneric() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/nestedClassExtendsOuterGeneric.kt"); + } + + @Test + @TestMetadata("nestedClassInObject.kt") + public void testNestedClassInObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/nestedClassInObject.kt"); + } + + @Test + @TestMetadata("nestedClassNotAllowed_after.kt") + public void testNestedClassNotAllowed_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/nestedClassNotAllowed_after.kt"); + } + + @Test + @TestMetadata("nestedClassNotAllowed_before.kt") + public void testNestedClassNotAllowed_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/nestedClassNotAllowed_before.kt"); + } + + @Test + @TestMetadata("nestedObject.kt") + public void testNestedObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/nestedObject.kt"); + } + + @Test + @TestMetadata("nestedVsInnerAccessOuterMember.kt") + public void testNestedVsInnerAccessOuterMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/nestedVsInnerAccessOuterMember.kt"); + } + + @Test + @TestMetadata("outerGenericParam.kt") + public void testOuterGenericParam() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/outerGenericParam.kt"); + } + + @Test + @TestMetadata("outerProtectedMember.kt") + public void testOuterProtectedMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/outerProtectedMember.kt"); + } + + @Test + @TestMetadata("outerSuperClassMember.kt") + public void testOuterSuperClassMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/outerSuperClassMember.kt"); + } + + @Test + @TestMetadata("referenceToSelfInLocal.kt") + public void testReferenceToSelfInLocal() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/referenceToSelfInLocal.kt"); + } + + @Test + @TestMetadata("resolvePackageClassInObjects.kt") + public void testResolvePackageClassInObjects() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/resolvePackageClassInObjects.kt"); + } + + @Test + @TestMetadata("selfAnnotationForClassObject.kt") + public void testSelfAnnotationForClassObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/selfAnnotationForClassObject.kt"); + } + + @Test + @TestMetadata("traits.kt") + public void testTraits() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/traits.kt"); + } + + @Test + @TestMetadata("typeVarianceConflict.kt") + public void testTypeVarianceConflict() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/typeVarianceConflict.kt"); + } + + @Test + @TestMetadata("typeVarianceConflictFeatureOn.kt") + public void testTypeVarianceConflictFeatureOn() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/typeVarianceConflictFeatureOn.kt"); + } + + @Test + @TestMetadata("visibility.kt") + public void testVisibility() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/visibility.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/inner/qualifiedExpression") + @TestDataPath("$PROJECT_ROOT") + public class QualifiedExpression { + @Test + public void testAllFilesPresentInQualifiedExpression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inner/qualifiedExpression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("classObjectOfNestedClass.kt") + public void testClassObjectOfNestedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/qualifiedExpression/classObjectOfNestedClass.kt"); + } + + @Test + @TestMetadata("constructNestedClass.kt") + public void testConstructNestedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/qualifiedExpression/constructNestedClass.kt"); + } + + @Test + @TestMetadata("dataLocalVariable.kt") + public void testDataLocalVariable() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/qualifiedExpression/dataLocalVariable.kt"); + } + + @Test + @TestMetadata("enumConstant.kt") + public void testEnumConstant() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/qualifiedExpression/enumConstant.kt"); + } + + @Test + @TestMetadata("genericNestedClass.kt") + public void testGenericNestedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/qualifiedExpression/genericNestedClass.kt"); + } + + @Test + @TestMetadata("importNestedClass.kt") + public void testImportNestedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/qualifiedExpression/importNestedClass.kt"); + } + + @Test + @TestMetadata("nestedClassInPackage.kt") + public void testNestedClassInPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/qualifiedExpression/nestedClassInPackage.kt"); + } + + @Test + @TestMetadata("nestedEnumConstant.kt") + public void testNestedEnumConstant() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/qualifiedExpression/nestedEnumConstant.kt"); + } + + @Test + @TestMetadata("nestedObjects.kt") + public void testNestedObjects() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/qualifiedExpression/nestedObjects.kt"); + } + + @Test + @TestMetadata("typePosition.kt") + public void testTypePosition() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/qualifiedExpression/typePosition.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/integerLiterals") + @TestDataPath("$PROJECT_ROOT") + public class IntegerLiterals { + @Test + public void testAllFilesPresentInIntegerLiterals() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/integerLiterals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("constantUnaryOperators.kt") + public void testConstantUnaryOperators() throws Exception { + runTest("compiler/testData/diagnostics/tests/integerLiterals/constantUnaryOperators.kt"); + } + + @Test + @TestMetadata("intToLongConversion.kt") + public void testIntToLongConversion() throws Exception { + runTest("compiler/testData/diagnostics/tests/integerLiterals/intToLongConversion.kt"); + } + + @Test + @TestMetadata("literalsInInference.kt") + public void testLiteralsInInference() throws Exception { + runTest("compiler/testData/diagnostics/tests/integerLiterals/literalsInInference.kt"); + } + + @Test + @TestMetadata("typealiasOnLong.kt") + public void testTypealiasOnLong() throws Exception { + runTest("compiler/testData/diagnostics/tests/integerLiterals/typealiasOnLong.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/j+k") + @TestDataPath("$PROJECT_ROOT") + public class J_k { + @Test + @TestMetadata("accessClassObjectFromJava.kt") + public void testAccessClassObjectFromJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/accessClassObjectFromJava.kt"); + } + + @Test + public void testAllFilesPresentInJ_k() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("ambiguousSamAdapters.kt") + public void testAmbiguousSamAdapters() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/ambiguousSamAdapters.kt"); + } + + @Test + @TestMetadata("annotationWithArgumentsMissingDependencies.kt") + public void testAnnotationWithArgumentsMissingDependencies() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/annotationWithArgumentsMissingDependencies.kt"); + } + + @Test + @TestMetadata("annotationsInheritance.kt") + public void testAnnotationsInheritance() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/annotationsInheritance.kt"); + } + + @Test + @TestMetadata("arrayOfStarParametrized.kt") + public void testArrayOfStarParametrized() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/arrayOfStarParametrized.kt"); + } + + @Test + @TestMetadata("callableReferencesStaticMemberClash.kt") + public void testCallableReferencesStaticMemberClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/callableReferencesStaticMemberClash.kt"); + } + + @Test + @TestMetadata("canDeclareIfSamAdapterIsInherited.kt") + public void testCanDeclareIfSamAdapterIsInherited() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/canDeclareIfSamAdapterIsInherited.kt"); + } + + @Test + @TestMetadata("collectorInference.kt") + public void testCollectorInference() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/collectorInference.kt"); + } + + @Test + @TestMetadata("computeIfAbsentConcurrent.kt") + public void testComputeIfAbsentConcurrent() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/computeIfAbsentConcurrent.kt"); + } + + @Test + @TestMetadata("contravariantIterable.kt") + public void testContravariantIterable() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/contravariantIterable.kt"); + } + + @Test + @TestMetadata("defaultMethods.kt") + public void testDefaultMethods() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/defaultMethods.kt"); + } + + @Test + @TestMetadata("defaultMethodsIndirectInheritance.kt") + public void testDefaultMethodsIndirectInheritance() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/defaultMethodsIndirectInheritance.kt"); + } + + @Test + @TestMetadata("differentFilename.kt") + public void testDifferentFilename() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/differentFilename.kt"); + } + + @Test + @TestMetadata("enumGetOrdinal.kt") + public void testEnumGetOrdinal() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/enumGetOrdinal.kt"); + } + + @Test + @TestMetadata("exceptionMessage.kt") + public void testExceptionMessage() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/exceptionMessage.kt"); + } + + @Test + @TestMetadata("fieldOverridesField.kt") + public void testFieldOverridesField() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/fieldOverridesField.kt"); + } + + @Test + @TestMetadata("fieldOverridesFieldOfDifferentType.kt") + public void testFieldOverridesFieldOfDifferentType() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/fieldOverridesFieldOfDifferentType.kt"); + } + + @Test + @TestMetadata("fieldOverridesNothing.kt") + public void testFieldOverridesNothing() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/fieldOverridesNothing.kt"); + } + + @Test + @TestMetadata("finalCollectionSize.kt") + public void testFinalCollectionSize() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/finalCollectionSize.kt"); + } + + @Test + @TestMetadata("flexibleNothing.kt") + public void testFlexibleNothing() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/flexibleNothing.kt"); + } + + @Test + @TestMetadata("flexibleTypeVariablePosition.kt") + public void testFlexibleTypeVariablePosition() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/flexibleTypeVariablePosition.kt"); + } + + @Test + @TestMetadata("genericConstructorWithMultipleBounds.kt") + public void testGenericConstructorWithMultipleBounds() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/genericConstructorWithMultipleBounds.kt"); + } + + @Test + @TestMetadata("GenericsInSupertypes.kt") + public void testGenericsInSupertypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/GenericsInSupertypes.kt"); + } + + @Test + @TestMetadata("inheritAbstractSamAdapter.kt") + public void testInheritAbstractSamAdapter() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/inheritAbstractSamAdapter.kt"); + } + + @Test + @TestMetadata("inheritanceStaticMethodFromInterface.kt") + public void testInheritanceStaticMethodFromInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/inheritanceStaticMethodFromInterface.kt"); + } + + @Test + @TestMetadata("InheritedGenericFunction.kt") + public void testInheritedGenericFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/InheritedGenericFunction.kt"); + } + + @Test + @TestMetadata("InnerClassFromJava.kt") + public void testInnerClassFromJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/InnerClassFromJava.kt"); + } + + @Test + @TestMetadata("innerLightClass.kt") + public void testInnerLightClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/innerLightClass.kt"); + } + + @Test + @TestMetadata("innerNestedClassFromJava.kt") + public void testInnerNestedClassFromJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/innerNestedClassFromJava.kt"); + } + + @Test + @TestMetadata("integerNotNullable.kt") + public void testIntegerNotNullable() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/integerNotNullable.kt"); + } + + @Test + @TestMetadata("invisiblePackagePrivateInheritedMember.kt") + public void testInvisiblePackagePrivateInheritedMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/invisiblePackagePrivateInheritedMember.kt"); + } + + @Test + @TestMetadata("javaStaticImport.kt") + public void testJavaStaticImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/javaStaticImport.kt"); + } + + @Test + @TestMetadata("KJKInheritance.kt") + public void testKJKInheritance() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/KJKInheritance.kt"); + } + + @Test + @TestMetadata("KJKInheritanceGeneric.kt") + public void testKJKInheritanceGeneric() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/KJKInheritanceGeneric.kt"); + } + + @Test + @TestMetadata("kt1402.kt") + public void testKt1402() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/kt1402.kt"); + } + + @Test + @TestMetadata("kt1431.kt") + public void testKt1431() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/kt1431.kt"); + } + + @Test + @TestMetadata("kt1730_implementCharSequence.kt") + public void testKt1730_implementCharSequence() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/kt1730_implementCharSequence.kt"); + } + + @Test + @TestMetadata("kt2152.kt") + public void testKt2152() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/kt2152.kt"); + } + + @Test + @TestMetadata("kt2394.kt") + public void testKt2394() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/kt2394.kt"); + } + + @Test + @TestMetadata("kt2606.kt") + public void testKt2606() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/kt2606.kt"); + } + + @Test + @TestMetadata("kt2619.kt") + public void testKt2619() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/kt2619.kt"); + } + + @Test + @TestMetadata("kt2641.kt") + public void testKt2641() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/kt2641.kt"); + } + + @Test + @TestMetadata("kt2890.kt") + public void testKt2890() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/kt2890.kt"); + } + + @Test + @TestMetadata("kt3307.kt") + public void testKt3307() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/kt3307.kt"); + } + + @Test + @TestMetadata("kt3311.kt") + public void testKt3311() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/kt3311.kt"); + } + + @Test + @TestMetadata("kt36856.kt") + public void testKt36856() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/kt36856.kt"); + } + + @Test + @TestMetadata("kt6720_abstractProperty.kt") + public void testKt6720_abstractProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/kt6720_abstractProperty.kt"); + } + + @Test + @TestMetadata("kt7523.kt") + public void testKt7523() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/kt7523.kt"); + } + + @Test + @TestMetadata("matchers.kt") + public void testMatchers() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/matchers.kt"); + } + + @Test + @TestMetadata("mutableIterator.kt") + public void testMutableIterator() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/mutableIterator.kt"); + } + + @Test + @TestMetadata("nullForOptionalOrElse.kt") + public void testNullForOptionalOrElse() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/nullForOptionalOrElse.kt"); + } + + @Test + @TestMetadata("orderOfSupertypesAndFakeOverrides_1.kt") + public void testOrderOfSupertypesAndFakeOverrides_1() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/orderOfSupertypesAndFakeOverrides_1.kt"); + } + + @Test + @TestMetadata("orderOfSupertypesAndFakeOverrides_2.kt") + public void testOrderOfSupertypesAndFakeOverrides_2() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/orderOfSupertypesAndFakeOverrides_2.kt"); + } + + @Test + @TestMetadata("overrideRawType.kt") + public void testOverrideRawType() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/overrideRawType.kt"); + } + + @Test + @TestMetadata("OverrideVararg.kt") + public void testOverrideVararg() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/OverrideVararg.kt"); + } + + @Test + @TestMetadata("overrideWithErasure.kt") + public void testOverrideWithErasure() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/overrideWithErasure.kt"); + } + + @Test + @TestMetadata("overrideWithSamAndTypeParameter.kt") + public void testOverrideWithSamAndTypeParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/overrideWithSamAndTypeParameter.kt"); + } + + @Test + @TestMetadata("packagePrivateClassStaticMember.kt") + public void testPackagePrivateClassStaticMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/packagePrivateClassStaticMember.kt"); + } + + @Test + @TestMetadata("packageVisibility.kt") + public void testPackageVisibility() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/packageVisibility.kt"); + } + + @Test + @TestMetadata("privateFieldOverridesNothing.kt") + public void testPrivateFieldOverridesNothing() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/privateFieldOverridesNothing.kt"); + } + + @Test + @TestMetadata("privateNestedClassStaticMember.kt") + public void testPrivateNestedClassStaticMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/privateNestedClassStaticMember.kt"); + } + + @Test + @TestMetadata("protectedStaticSamePackage.kt") + public void testProtectedStaticSamePackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/protectedStaticSamePackage.kt"); + } + + @Test + @TestMetadata("purelyImplementedSupertype.kt") + public void testPurelyImplementedSupertype() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/purelyImplementedSupertype.kt"); + } + + @Test + @TestMetadata("rawOverride.kt") + public void testRawOverride() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/rawOverride.kt"); + } + + @Test + @TestMetadata("rawTypeScope.kt") + public void testRawTypeScope() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/rawTypeScope.kt"); + } + + @Test + @TestMetadata("rawTypesFromCaptured.kt") + public void testRawTypesFromCaptured() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/rawTypesFromCaptured.kt"); + } + + @Test + @TestMetadata("rawTypesFromCapturedOriginal.kt") + public void testRawTypesFromCapturedOriginal() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/rawTypesFromCapturedOriginal.kt"); + } + + @Test + @TestMetadata("rawUpperBounds.kt") + public void testRawUpperBounds() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/rawUpperBounds.kt"); + } + + @Test + @TestMetadata("recursionWithJavaSyntheticProperty.kt") + public void testRecursionWithJavaSyntheticProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/recursionWithJavaSyntheticProperty.kt"); + } + + @Test + @TestMetadata("recursiveRawUpperBound.kt") + public void testRecursiveRawUpperBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/recursiveRawUpperBound.kt"); + } + + @Test + @TestMetadata("recursiveRawUpperBound2.kt") + public void testRecursiveRawUpperBound2() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/recursiveRawUpperBound2.kt"); + } + + @Test + @TestMetadata("recursiveRawUpperBound3.kt") + public void testRecursiveRawUpperBound3() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/recursiveRawUpperBound3.kt"); + } + + @Test + @TestMetadata("recursiveSelfTypes.kt") + public void testRecursiveSelfTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/recursiveSelfTypes.kt"); + } + + @Test + @TestMetadata("safeCallDefinitelyNotNull.kt") + public void testSafeCallDefinitelyNotNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/safeCallDefinitelyNotNull.kt"); + } + + @Test + @TestMetadata("samInConstructorWithGenerics.kt") + public void testSamInConstructorWithGenerics() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/samInConstructorWithGenerics.kt"); + } + + @Test + @TestMetadata("samWithConsumer.kt") + public void testSamWithConsumer() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/samWithConsumer.kt"); + } + + @Test + @TestMetadata("selectMoreSpecific.kt") + public void testSelectMoreSpecific() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/selectMoreSpecific.kt"); + } + + @Test + @TestMetadata("serializable.kt") + public void testSerializable() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/serializable.kt"); + } + + @Test + @TestMetadata("shadowingPrimitiveStaticField.kt") + public void testShadowingPrimitiveStaticField() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/shadowingPrimitiveStaticField.kt"); + } + + @Test + @TestMetadata("Simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/Simple.kt"); + } + + @Test + @TestMetadata("specialBridges.kt") + public void testSpecialBridges() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/specialBridges.kt"); + } + + @Test + @TestMetadata("StaticMembersFromSuperclasses.kt") + public void testStaticMembersFromSuperclasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/StaticMembersFromSuperclasses.kt"); + } + + @Test + @TestMetadata("staticMethodInClass.kt") + public void testStaticMethodInClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/staticMethodInClass.kt"); + } + + @Test + @TestMetadata("SupertypeArgumentsNullability-NotNull-SpecialTypes.kt") + public void testSupertypeArgumentsNullability_NotNull_SpecialTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-SpecialTypes.kt"); + } + + @Test + @TestMetadata("SupertypeArgumentsNullability-NotNull-UserTypes.kt") + public void testSupertypeArgumentsNullability_NotNull_UserTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-UserTypes.kt"); + } + + @Test + @TestMetadata("SupertypeArgumentsNullability-SpecialTypes.kt") + public void testSupertypeArgumentsNullability_SpecialTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-SpecialTypes.kt"); + } + + @Test + @TestMetadata("SupertypeArgumentsNullability-UserTypes.kt") + public void testSupertypeArgumentsNullability_UserTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-UserTypes.kt"); + } + + @Test + @TestMetadata("supertypeUsesNested.kt") + public void testSupertypeUsesNested() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/supertypeUsesNested.kt"); + } + + @Test + @TestMetadata("syntheticAssignmentInLambdaExpressionBody.kt") + public void testSyntheticAssignmentInLambdaExpressionBody() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/syntheticAssignmentInLambdaExpressionBody.kt"); + } + + @Test + @TestMetadata("syntheticPropertyOverridden.kt") + public void testSyntheticPropertyOverridden() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/syntheticPropertyOverridden.kt"); + } + + @Test + @TestMetadata("syntheticPropertyOverridden2.kt") + public void testSyntheticPropertyOverridden2() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/syntheticPropertyOverridden2.kt"); + } + + @Test + @TestMetadata("traitDefaultCall.kt") + public void testTraitDefaultCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/traitDefaultCall.kt"); + } + + @Test + @TestMetadata("typeAliasWithSamConstructor.kt") + public void testTypeAliasWithSamConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/typeAliasWithSamConstructor.kt"); + } + + @Test + @TestMetadata("UnboxingNulls.kt") + public void testUnboxingNulls() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/UnboxingNulls.kt"); + } + + @Test + @TestMetadata("wrongVarianceInJava.kt") + public void testWrongVarianceInJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/wrongVarianceInJava.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/j+k/brokenCode") + @TestDataPath("$PROJECT_ROOT") + public class BrokenCode { + @Test + public void testAllFilesPresentInBrokenCode() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/brokenCode"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("classDuplicates.kt") + public void testClassDuplicates() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/brokenCode/classDuplicates.kt"); + } + + @Test + @TestMetadata("fieldDuplicates.kt") + public void testFieldDuplicates() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/brokenCode/fieldDuplicates.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/j+k/collectionOverrides") + @TestDataPath("$PROJECT_ROOT") + public class CollectionOverrides { + @Test + public void testAllFilesPresentInCollectionOverrides() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/collectionOverrides"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("charBuffer.kt") + public void testCharBuffer() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/charBuffer.kt"); + } + + @Test + @TestMetadata("collectionStringImpl.kt") + public void testCollectionStringImpl() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/collectionStringImpl.kt"); + } + + @Test + @TestMetadata("commonCollections.kt") + public void testCommonCollections() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/commonCollections.kt"); + } + + @Test + @TestMetadata("contains.kt") + public void testContains() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/contains.kt"); + } + + @Test + @TestMetadata("containsAll.kt") + public void testContainsAll() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/containsAll.kt"); + } + + @Test + @TestMetadata("containsAndOverload.kt") + public void testContainsAndOverload() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/containsAndOverload.kt"); + } + + @Test + @TestMetadata("getCharSequence.kt") + public void testGetCharSequence() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/getCharSequence.kt"); + } + + @Test + @TestMetadata("irrelevantCharAtAbstract.kt") + public void testIrrelevantCharAtAbstract() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/irrelevantCharAtAbstract.kt"); + } + + @Test + @TestMetadata("irrelevantImplCharSequence.kt") + public void testIrrelevantImplCharSequence() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/irrelevantImplCharSequence.kt"); + } + + @Test + @TestMetadata("irrelevantImplCharSequenceKotlin.kt") + public void testIrrelevantImplCharSequenceKotlin() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/irrelevantImplCharSequenceKotlin.kt"); + } + + @Test + @TestMetadata("irrelevantImplMutableList.kt") + public void testIrrelevantImplMutableList() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/irrelevantImplMutableList.kt"); + } + + @Test + @TestMetadata("irrelevantImplMutableListKotlin.kt") + public void testIrrelevantImplMutableListKotlin() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/irrelevantImplMutableListKotlin.kt"); + } + + @Test + @TestMetadata("irrelevantMapGetAbstract.kt") + public void testIrrelevantMapGetAbstract() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/irrelevantMapGetAbstract.kt"); + } + + @Test + @TestMetadata("mapGetOverride.kt") + public void testMapGetOverride() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/mapGetOverride.kt"); + } + + @Test + @TestMetadata("overridesBuiltinNoMagic.kt") + public void testOverridesBuiltinNoMagic() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/overridesBuiltinNoMagic.kt"); + } + + @Test + @TestMetadata("removeAt.kt") + public void testRemoveAt() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/removeAt.kt"); + } + + @Test + @TestMetadata("removeAtInt.kt") + public void testRemoveAtInt() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/removeAtInt.kt"); + } + + @Test + @TestMetadata("sizeFromKotlinOverriddenInJava.kt") + public void testSizeFromKotlinOverriddenInJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/sizeFromKotlinOverriddenInJava.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/j+k/deprecations") + @TestDataPath("$PROJECT_ROOT") + public class Deprecations { + @Test + public void testAllFilesPresentInDeprecations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/deprecations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("forFakeOverrides.kt") + public void testForFakeOverrides() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/deprecations/forFakeOverrides.kt"); + } + + @Test + @TestMetadata("forMixedOverride.kt") + public void testForMixedOverride() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/deprecations/forMixedOverride.kt"); + } + + @Test + @TestMetadata("forOverrides.kt") + public void testForOverrides() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/deprecations/forOverrides.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/j+k/genericConstructor") + @TestDataPath("$PROJECT_ROOT") + public class GenericConstructor { + @Test + public void testAllFilesPresentInGenericConstructor() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/genericConstructor"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("classTypeParameterInferredFromArgument.kt") + public void testClassTypeParameterInferredFromArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/genericConstructor/classTypeParameterInferredFromArgument.kt"); + } + + @Test + @TestMetadata("innerClass.kt") + public void testInnerClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/genericConstructor/innerClass.kt"); + } + + @Test + @TestMetadata("noClassTypeParameters.kt") + public void testNoClassTypeParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/genericConstructor/noClassTypeParameters.kt"); + } + + @Test + @TestMetadata("noClassTypeParametersInvParameter.kt") + public void testNoClassTypeParametersInvParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/genericConstructor/noClassTypeParametersInvParameter.kt"); + } + + @Test + @TestMetadata("recursive.kt") + public void testRecursive() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/genericConstructor/recursive.kt"); + } + + @Test + @TestMetadata("selfTypes.kt") + public void testSelfTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/genericConstructor/selfTypes.kt"); + } + + @Test + @TestMetadata("superCall.kt") + public void testSuperCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/genericConstructor/superCall.kt"); + } + + @Test + @TestMetadata("superCallImpossibleToInfer.kt") + public void testSuperCallImpossibleToInfer() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/genericConstructor/superCallImpossibleToInfer.kt"); + } + + @Test + @TestMetadata("withClassTypeParameters.kt") + public void testWithClassTypeParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/genericConstructor/withClassTypeParameters.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/j+k/polymorphicSignature") + @TestDataPath("$PROJECT_ROOT") + public class PolymorphicSignature { + @Test + public void testAllFilesPresentInPolymorphicSignature() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/polymorphicSignature"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("spreadOperator_after.kt") + public void testSpreadOperator_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_after.kt"); + } + + @Test + @TestMetadata("spreadOperator_before.kt") + public void testSpreadOperator_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_before.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/j+k/primitiveOverrides") + @TestDataPath("$PROJECT_ROOT") + public class PrimitiveOverrides { + @Test + public void testAllFilesPresentInPrimitiveOverrides() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/primitiveOverrides"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("kt11140.kt") + public void testKt11140() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/primitiveOverrides/kt11140.kt"); + } + + @Test + @TestMetadata("notNullAnnotated.kt") + public void testNotNullAnnotated() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/primitiveOverrides/notNullAnnotated.kt"); + } + + @Test + @TestMetadata("specializedMap.kt") + public void testSpecializedMap() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/primitiveOverrides/specializedMap.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/j+k/primitiveOverridesWithInlineClass") + @TestDataPath("$PROJECT_ROOT") + public class PrimitiveOverridesWithInlineClass { + @Test + public void testAllFilesPresentInPrimitiveOverridesWithInlineClass() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/primitiveOverridesWithInlineClass"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("inlineClassErasedToPrimitiveInt.kt") + public void testInlineClassErasedToPrimitiveInt() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/primitiveOverridesWithInlineClass/inlineClassErasedToPrimitiveInt.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/j+k/properties") + @TestDataPath("$PROJECT_ROOT") + public class Properties { + @Test + public void testAllFilesPresentInProperties() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/properties"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("fieldPropertyOverloads.kt") + public void testFieldPropertyOverloads() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/properties/fieldPropertyOverloads.kt"); + } + + @Test + @TestMetadata("fieldPropertyOverloadsDisabled.kt") + public void testFieldPropertyOverloadsDisabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/properties/fieldPropertyOverloadsDisabled.kt"); + } + + @Test + @TestMetadata("fieldPropertyOverloadsNI.kt") + public void testFieldPropertyOverloadsNI() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/properties/fieldPropertyOverloadsNI.kt"); + } + + @Test + @TestMetadata("interface.kt") + public void testInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/properties/interface.kt"); + } + + @Test + @TestMetadata("isName.kt") + public void testIsName() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/properties/isName.kt"); + } + + @Test + @TestMetadata("staticFieldPropertyOverloads.kt") + public void testStaticFieldPropertyOverloads() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/properties/staticFieldPropertyOverloads.kt"); + } + + @Test + @TestMetadata("val.kt") + public void testVal() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/properties/val.kt"); + } + + @Test + @TestMetadata("var.kt") + public void testVar() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/properties/var.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/j+k/sam") + @TestDataPath("$PROJECT_ROOT") + public class Sam { + @Test + public void testAllFilesPresentInSam() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/sam"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("compatibilityResolveToOuterScopeForKotlinFunctions.kt") + public void testCompatibilityResolveToOuterScopeForKotlinFunctions() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/sam/compatibilityResolveToOuterScopeForKotlinFunctions.kt"); + } + + @Test + @TestMetadata("conversionForDerivedGenericClass.kt") + public void testConversionForDerivedGenericClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/sam/conversionForDerivedGenericClass.kt"); + } + + @Test + @TestMetadata("conversionsWithNestedGenerics.kt") + public void testConversionsWithNestedGenerics() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/sam/conversionsWithNestedGenerics.kt"); + } + + @Test + @TestMetadata("enhancedSamConstructor.kt") + public void testEnhancedSamConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/sam/enhancedSamConstructor.kt"); + } + + @Test + @TestMetadata("fakeOverrideFunctionForStaticSam.kt") + public void testFakeOverrideFunctionForStaticSam() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/sam/fakeOverrideFunctionForStaticSam.kt"); + } + + @Test + @TestMetadata("inheritedStaticSam.kt") + public void testInheritedStaticSam() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/sam/inheritedStaticSam.kt"); + } + + @Test + @TestMetadata("kt37920.kt") + public void testKt37920() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/sam/kt37920.kt"); + } + + @Test + @TestMetadata("kt39630.kt") + public void testKt39630() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/sam/kt39630.kt"); + } + + @Test + @TestMetadata("privateCandidatesWithWrongArguments.kt") + public void testPrivateCandidatesWithWrongArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/sam/privateCandidatesWithWrongArguments.kt"); + } + + @Test + @TestMetadata("recursiveSamsAndInvoke.kt") + public void testRecursiveSamsAndInvoke() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/sam/recursiveSamsAndInvoke.kt"); + } + + @Test + @TestMetadata("referenceToSamFunctionAgainstExpectedType.kt") + public void testReferenceToSamFunctionAgainstExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/sam/referenceToSamFunctionAgainstExpectedType.kt"); + } + + @Test + @TestMetadata("samOnTypeParameter.kt") + public void testSamOnTypeParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/sam/samOnTypeParameter.kt"); + } + + @Test + @TestMetadata("staticSamFromImportWithStar.kt") + public void testStaticSamFromImportWithStar() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/sam/staticSamFromImportWithStar.kt"); + } + + @Test + @TestMetadata("staticSamWithExplicitImport.kt") + public void testStaticSamWithExplicitImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/sam/staticSamWithExplicitImport.kt"); + } + + @Test + @TestMetadata("typeInferenceOnSamAdapters.kt") + public void testTypeInferenceOnSamAdapters() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/sam/typeInferenceOnSamAdapters.kt"); + } + + @Test + @TestMetadata("withDefaultMethods.kt") + public void testWithDefaultMethods() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/sam/withDefaultMethods.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/j+k/samByProjectedType") + @TestDataPath("$PROJECT_ROOT") + public class SamByProjectedType { + @Test + public void testAllFilesPresentInSamByProjectedType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/samByProjectedType"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("genericInReturnType.kt") + public void testGenericInReturnType() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericInReturnType.kt"); + } + + @Test + @TestMetadata("genericInValueParameter.kt") + public void testGenericInValueParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericInValueParameter.kt"); + } + + @Test + @TestMetadata("genericSuperWildcard.kt") + public void testGenericSuperWildcard() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericSuperWildcard.kt"); + } + + @Test + @TestMetadata("noAdapterBecuaseOfRecursiveUpperBound.kt") + public void testNoAdapterBecuaseOfRecursiveUpperBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/samByProjectedType/noAdapterBecuaseOfRecursiveUpperBound.kt"); + } + + @Test + @TestMetadata("starProjectionComplexUpperBound.kt") + public void testStarProjectionComplexUpperBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/samByProjectedType/starProjectionComplexUpperBound.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/j+k/signatureAnnotations") + @TestDataPath("$PROJECT_ROOT") + public class SignatureAnnotations { + @Test + public void testAllFilesPresentInSignatureAnnotations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/signatureAnnotations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("notNullVarargOverride.kt") + public void testNotNullVarargOverride() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/signatureAnnotations/notNullVarargOverride.kt"); + } + + @Test + @TestMetadata("nullableVarargOverride.kt") + public void testNullableVarargOverride() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/signatureAnnotations/nullableVarargOverride.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/j+k/specialBuiltIns") + @TestDataPath("$PROJECT_ROOT") + public class SpecialBuiltIns { + @Test + public void testAllFilesPresentInSpecialBuiltIns() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/specialBuiltIns"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("hashtableInheritance.kt") + public void testHashtableInheritance() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/specialBuiltIns/hashtableInheritance.kt"); + } + + @Test + @TestMetadata("securityProvider.kt") + public void testSecurityProvider() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/specialBuiltIns/securityProvider.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/j+k/types") + @TestDataPath("$PROJECT_ROOT") + public class Types { + @Test + public void testAllFilesPresentInTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/types"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("arrayList.kt") + public void testArrayList() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/types/arrayList.kt"); + } + + @Test + @TestMetadata("constantStaticStringField.kt") + public void testConstantStaticStringField() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/types/constantStaticStringField.kt"); + } + + @Test + @TestMetadata("noOverrideKeyword.kt") + public void testNoOverrideKeyword() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/types/noOverrideKeyword.kt"); + } + + @Test + @TestMetadata("notNullTypeParameterWithKotlinNullable.kt") + public void testNotNullTypeParameterWithKotlinNullable() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullable.kt"); + } + + @Test + @TestMetadata("notNullTypeParameterWithKotlinNullableWarnings.kt") + public void testNotNullTypeParameterWithKotlinNullableWarnings() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullableWarnings.kt"); + } + + @Test + @TestMetadata("notNullTypeParameterWithKotlinOverridesDefinitelyNonNullable.kt") + public void testNotNullTypeParameterWithKotlinOverridesDefinitelyNonNullable() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinOverridesDefinitelyNonNullable.kt"); + } + + @Test + @TestMetadata("notNullTypeParameterWithKotlinOverridesWarning.kt") + public void testNotNullTypeParameterWithKotlinOverridesWarning() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinOverridesWarning.kt"); + } + + @Test + @TestMetadata("returnCollection.kt") + public void testReturnCollection() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/types/returnCollection.kt"); + } + + @Test + @TestMetadata("shapeMismatchInCovariantPosition.kt") + public void testShapeMismatchInCovariantPosition() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/types/shapeMismatchInCovariantPosition.kt"); + } + + @Test + @TestMetadata("shapeMismatchInCovariantPositionGeneric.kt") + public void testShapeMismatchInCovariantPositionGeneric() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/types/shapeMismatchInCovariantPositionGeneric.kt"); + } + + @Test + @TestMetadata("typeParameter.kt") + public void testTypeParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/types/typeParameter.kt"); + } + + @Test + @TestMetadata("upperBoundsCheckAgainstSelfTypeInJava.kt") + public void testUpperBoundsCheckAgainstSelfTypeInJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/types/upperBoundsCheckAgainstSelfTypeInJava.kt"); + } + + @Test + @TestMetadata("varargOverride.kt") + public void testVarargOverride() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/types/varargOverride.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/java8Overrides") + @TestDataPath("$PROJECT_ROOT") + public class Java8Overrides { + @Test + @TestMetadata("abstractBaseClassMemberNotImplemented.kt") + public void testAbstractBaseClassMemberNotImplemented() throws Exception { + runTest("compiler/testData/diagnostics/tests/java8Overrides/abstractBaseClassMemberNotImplemented.kt"); + } + + @Test + @TestMetadata("abstractBaseClassMemberNotImplemented_15.kt") + public void testAbstractBaseClassMemberNotImplemented_15() throws Exception { + runTest("compiler/testData/diagnostics/tests/java8Overrides/abstractBaseClassMemberNotImplemented_15.kt"); + } + + @Test + @TestMetadata("abstractFakeOverrideSuperCall.kt") + public void testAbstractFakeOverrideSuperCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/java8Overrides/abstractFakeOverrideSuperCall.kt"); + } + + @Test + @TestMetadata("abstractFakeOverrideSuperCallForbidden.kt") + public void testAbstractFakeOverrideSuperCallForbidden() throws Exception { + runTest("compiler/testData/diagnostics/tests/java8Overrides/abstractFakeOverrideSuperCallForbidden.kt"); + } + + @Test + @TestMetadata("abstractFakeOverrideSuperCallOneMoreLevel.kt") + public void testAbstractFakeOverrideSuperCallOneMoreLevel() throws Exception { + runTest("compiler/testData/diagnostics/tests/java8Overrides/abstractFakeOverrideSuperCallOneMoreLevel.kt"); + } + + @Test + @TestMetadata("abstractVsAbstract.kt") + public void testAbstractVsAbstract() throws Exception { + runTest("compiler/testData/diagnostics/tests/java8Overrides/abstractVsAbstract.kt"); + } + + @Test + public void testAllFilesPresentInJava8Overrides() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/java8Overrides"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("defaultVsAbstract.kt") + public void testDefaultVsAbstract() throws Exception { + runTest("compiler/testData/diagnostics/tests/java8Overrides/defaultVsAbstract.kt"); + } + + @Test + @TestMetadata("falseManyImplementations.kt") + public void testFalseManyImplementations() throws Exception { + runTest("compiler/testData/diagnostics/tests/java8Overrides/falseManyImplementations.kt"); + } + + @Test + @TestMetadata("hidingMethodOfAny.kt") + public void testHidingMethodOfAny() throws Exception { + runTest("compiler/testData/diagnostics/tests/java8Overrides/hidingMethodOfAny.kt"); + } + + @Test + @TestMetadata("implementingMethodOfAny.kt") + public void testImplementingMethodOfAny() throws Exception { + runTest("compiler/testData/diagnostics/tests/java8Overrides/implementingMethodOfAny.kt"); + } + + @Test + @TestMetadata("kt45508.kt") + public void testKt45508() throws Exception { + runTest("compiler/testData/diagnostics/tests/java8Overrides/kt45508.kt"); + } + + @Test + @TestMetadata("notAMethodOfAny.kt") + public void testNotAMethodOfAny() throws Exception { + runTest("compiler/testData/diagnostics/tests/java8Overrides/notAMethodOfAny.kt"); + } + + @Test + @TestMetadata("overridingMethodOfAnyChain.kt") + public void testOverridingMethodOfAnyChain() throws Exception { + runTest("compiler/testData/diagnostics/tests/java8Overrides/overridingMethodOfAnyChain.kt"); + } + + @Test + @TestMetadata("overridingMethodOfAnyDiamond.kt") + public void testOverridingMethodOfAnyDiamond() throws Exception { + runTest("compiler/testData/diagnostics/tests/java8Overrides/overridingMethodOfAnyDiamond.kt"); + } + + @Test + @TestMetadata("singleRelevantDefault.kt") + public void testSingleRelevantDefault() throws Exception { + runTest("compiler/testData/diagnostics/tests/java8Overrides/singleRelevantDefault.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/javac") + @TestDataPath("$PROJECT_ROOT") + public class Javac { + @Test + public void testAllFilesPresentInJavac() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("Annotations.kt") + public void testAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/Annotations.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/javac/fieldsResolution") + @TestDataPath("$PROJECT_ROOT") + public class FieldsResolution { + @Test + public void testAllFilesPresentInFieldsResolution() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/fieldsResolution"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("AsteriskStaticImportsAmbiguity.kt") + public void testAsteriskStaticImportsAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/AsteriskStaticImportsAmbiguity.kt"); + } + + @Test + @TestMetadata("BinaryInitializers.kt") + public void testBinaryInitializers() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/BinaryInitializers.kt"); + } + + @Test + @TestMetadata("ConstantByFqName.kt") + public void testConstantByFqName() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantByFqName.kt"); + } + + @Test + @TestMetadata("ConstantValues.kt") + public void testConstantValues() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantValues.kt"); + } + + @Test + @TestMetadata("ConstantValuesFromKtFile.kt") + public void testConstantValuesFromKtFile() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantValuesFromKtFile.kt"); + } + + @Test + @TestMetadata("FieldFromOuterClass.kt") + public void testFieldFromOuterClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/FieldFromOuterClass.kt"); + } + + @Test + @TestMetadata("InheritedField.kt") + public void testInheritedField() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/InheritedField.kt"); + } + + @Test + @TestMetadata("MultipleOuters.kt") + public void testMultipleOuters() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/MultipleOuters.kt"); + } + + @Test + @TestMetadata("ResolutionPriority.kt") + public void testResolutionPriority() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/ResolutionPriority.kt"); + } + + @Test + @TestMetadata("SameFieldInSupertypes.kt") + public void testSameFieldInSupertypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/SameFieldInSupertypes.kt"); + } + + @Test + @TestMetadata("StaticImport.kt") + public void testStaticImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/StaticImport.kt"); + } + + @Test + @TestMetadata("StaticImportsAmbiguity.kt") + public void testStaticImportsAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/StaticImportsAmbiguity.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/javac/imports") + @TestDataPath("$PROJECT_ROOT") + public class Imports { + @Test + public void testAllFilesPresentInImports() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/imports"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("AllUnderImportsAmbiguity.kt") + public void testAllUnderImportsAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/AllUnderImportsAmbiguity.kt"); + } + + @Test + @TestMetadata("AllUnderImportsLessPriority.kt") + public void testAllUnderImportsLessPriority() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/AllUnderImportsLessPriority.kt"); + } + + @Test + @TestMetadata("ClassImportsConflicting.kt") + public void testClassImportsConflicting() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/ClassImportsConflicting.kt"); + } + + @Test + @TestMetadata("CurrentPackageAndAllUnderImport.kt") + public void testCurrentPackageAndAllUnderImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndAllUnderImport.kt"); + } + + @Test + @TestMetadata("CurrentPackageAndExplicitImport.kt") + public void testCurrentPackageAndExplicitImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndExplicitImport.kt"); + } + + @Test + @TestMetadata("CurrentPackageAndExplicitNestedImport.kt") + public void testCurrentPackageAndExplicitNestedImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndExplicitNestedImport.kt"); + } + + @Test + @TestMetadata("CurrentPackageAndNestedAsteriskImport.kt") + public void testCurrentPackageAndNestedAsteriskImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndNestedAsteriskImport.kt"); + } + + @Test + @TestMetadata("ImportGenericVsPackage.kt") + public void testImportGenericVsPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/ImportGenericVsPackage.kt"); + } + + @Test + @TestMetadata("ImportProtectedClass.kt") + public void testImportProtectedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/ImportProtectedClass.kt"); + } + + @Test + @TestMetadata("ImportTwoTimes.kt") + public void testImportTwoTimes() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/ImportTwoTimes.kt"); + } + + @Test + @TestMetadata("ImportTwoTimesStar.kt") + public void testImportTwoTimesStar() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/ImportTwoTimesStar.kt"); + } + + @Test + @TestMetadata("NestedAndTopLevelClassClash.kt") + public void testNestedAndTopLevelClassClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/NestedAndTopLevelClassClash.kt"); + } + + @Test + @TestMetadata("NestedClassClash.kt") + public void testNestedClassClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/NestedClassClash.kt"); + } + + @Test + @TestMetadata("PackageExplicitAndStartImport.kt") + public void testPackageExplicitAndStartImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/PackageExplicitAndStartImport.kt"); + } + + @Test + @TestMetadata("PackagePrivateAndPublicNested.kt") + public void testPackagePrivateAndPublicNested() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/PackagePrivateAndPublicNested.kt"); + } + + @Test + @TestMetadata("TopLevelClassVsPackage.kt") + public void testTopLevelClassVsPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/TopLevelClassVsPackage.kt"); + } + + @Test + @TestMetadata("TopLevelClassVsPackage2.kt") + public void testTopLevelClassVsPackage2() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/TopLevelClassVsPackage2.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/javac/inheritance") + @TestDataPath("$PROJECT_ROOT") + public class Inheritance { + @Test + public void testAllFilesPresentInInheritance() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/inheritance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("IheritanceOfInner.kt") + public void testIheritanceOfInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/IheritanceOfInner.kt"); + } + + @Test + @TestMetadata("InheritanceAmbiguity.kt") + public void testInheritanceAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity.kt"); + } + + @Test + @TestMetadata("InheritanceAmbiguity2.kt") + public void testInheritanceAmbiguity2() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity2.kt"); + } + + @Test + @TestMetadata("InheritanceAmbiguity3.kt") + public void testInheritanceAmbiguity3() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity3.kt"); + } + + @Test + @TestMetadata("InheritanceAmbiguity4.kt") + public void testInheritanceAmbiguity4() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity4.kt"); + } + + @Test + @TestMetadata("InheritanceWithKotlin.kt") + public void testInheritanceWithKotlin() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritanceWithKotlin.kt"); + } + + @Test + @TestMetadata("InheritanceWithKotlinClasses.kt") + public void testInheritanceWithKotlinClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritanceWithKotlinClasses.kt"); + } + + @Test + @TestMetadata("InheritedInner.kt") + public void testInheritedInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritedInner.kt"); + } + + @Test + @TestMetadata("InheritedInner2.kt") + public void testInheritedInner2() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritedInner2.kt"); + } + + @Test + @TestMetadata("InheritedInnerAndSupertypeWithSameName.kt") + public void testInheritedInnerAndSupertypeWithSameName() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritedInnerAndSupertypeWithSameName.kt"); + } + + @Test + @TestMetadata("InheritedInnerUsageInInner.kt") + public void testInheritedInnerUsageInInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritedInnerUsageInInner.kt"); + } + + @Test + @TestMetadata("InheritedKotlinInner.kt") + public void testInheritedKotlinInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritedKotlinInner.kt"); + } + + @Test + @TestMetadata("InnerAndInheritedInner.kt") + public void testInnerAndInheritedInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InnerAndInheritedInner.kt"); + } + + @Test + @TestMetadata("ManyInheritedClasses.kt") + public void testManyInheritedClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/ManyInheritedClasses.kt"); + } + + @Test + @TestMetadata("SameInnersInSupertypeAndSupertypesSupertype.kt") + public void testSameInnersInSupertypeAndSupertypesSupertype() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/SameInnersInSupertypeAndSupertypesSupertype.kt"); + } + + @Test + @TestMetadata("SuperTypeWithSameInner.kt") + public void testSuperTypeWithSameInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/SuperTypeWithSameInner.kt"); + } + + @Test + @TestMetadata("SupertypeInnerAndTypeParameterWithSameNames.kt") + public void testSupertypeInnerAndTypeParameterWithSameNames() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/SupertypeInnerAndTypeParameterWithSameNames.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/javac/inners") + @TestDataPath("$PROJECT_ROOT") + public class Inners { + @Test + public void testAllFilesPresentInInners() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/inners"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("ComplexCase.kt") + public void testComplexCase() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/ComplexCase.kt"); + } + + @Test + @TestMetadata("ComplexCase2.kt") + public void testComplexCase2() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/ComplexCase2.kt"); + } + + @Test + @TestMetadata("CurrentPackageAndInner.kt") + public void testCurrentPackageAndInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/CurrentPackageAndInner.kt"); + } + + @Test + @TestMetadata("ImportThriceNestedClass.kt") + public void testImportThriceNestedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/ImportThriceNestedClass.kt"); + } + + @Test + @TestMetadata("InnerInInner.kt") + public void testInnerInInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/InnerInInner.kt"); + } + + @Test + @TestMetadata("Nested.kt") + public void testNested() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/Nested.kt"); + } + + @Test + @TestMetadata("ThriceNestedClass.kt") + public void testThriceNestedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/ThriceNestedClass.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/javac/qualifiedExpression") + @TestDataPath("$PROJECT_ROOT") + public class QualifiedExpression { + @Test + public void testAllFilesPresentInQualifiedExpression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/qualifiedExpression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("GenericClassVsPackage.kt") + public void testGenericClassVsPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/qualifiedExpression/GenericClassVsPackage.kt"); + } + + @Test + @TestMetadata("PackageVsClass.kt") + public void testPackageVsClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsClass.kt"); + } + + @Test + @TestMetadata("PackageVsClass2.kt") + public void testPackageVsClass2() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsClass2.kt"); + } + + @Test + @TestMetadata("PackageVsRootClass.kt") + public void testPackageVsRootClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsRootClass.kt"); + } + + @Test + @TestMetadata("visibleClassVsQualifiedClass.kt") + public void testVisibleClassVsQualifiedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/qualifiedExpression/visibleClassVsQualifiedClass.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/javac/typeParameters") + @TestDataPath("$PROJECT_ROOT") + public class TypeParameters { + @Test + public void testAllFilesPresentInTypeParameters() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/typeParameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("Clash.kt") + public void testClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/Clash.kt"); + } + + @Test + @TestMetadata("ComplexCase.kt") + public void testComplexCase() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/ComplexCase.kt"); + } + + @Test + @TestMetadata("InheritedInnerAndTypeParameterWithSameNames.kt") + public void testInheritedInnerAndTypeParameterWithSameNames() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/InheritedInnerAndTypeParameterWithSameNames.kt"); + } + + @Test + @TestMetadata("InnerWithTypeParameter.kt") + public void testInnerWithTypeParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/InnerWithTypeParameter.kt"); + } + + @Test + @TestMetadata("NestedWithInner.kt") + public void testNestedWithInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/NestedWithInner.kt"); + } + + @Test + @TestMetadata("SeveralInnersWithTypeParameters.kt") + public void testSeveralInnersWithTypeParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/SeveralInnersWithTypeParameters.kt"); + } + + @Test + @TestMetadata("TypeParametersInInnerAndOuterWithSameNames.kt") + public void testTypeParametersInInnerAndOuterWithSameNames() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/TypeParametersInInnerAndOuterWithSameNames.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/labels") + @TestDataPath("$PROJECT_ROOT") + public class Labels { + @Test + public void testAllFilesPresentInLabels() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/labels"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("automaticLabelFromInfixOperator.kt") + public void testAutomaticLabelFromInfixOperator() throws Exception { + runTest("compiler/testData/diagnostics/tests/labels/automaticLabelFromInfixOperator.kt"); + } + + @Test + @TestMetadata("kt1703.kt") + public void testKt1703() throws Exception { + runTest("compiler/testData/diagnostics/tests/labels/kt1703.kt"); + } + + @Test + @TestMetadata("kt361.kt") + public void testKt361() throws Exception { + runTest("compiler/testData/diagnostics/tests/labels/kt361.kt"); + } + + @Test + @TestMetadata("kt3920.kt") + public void testKt3920() throws Exception { + runTest("compiler/testData/diagnostics/tests/labels/kt3920.kt"); + } + + @Test + @TestMetadata("kt3988.kt") + public void testKt3988() throws Exception { + runTest("compiler/testData/diagnostics/tests/labels/kt3988.kt"); + } + + @Test + @TestMetadata("kt4247.kt") + public void testKt4247() throws Exception { + runTest("compiler/testData/diagnostics/tests/labels/kt4247.kt"); + } + + @Test + @TestMetadata("kt4586.kt") + public void testKt4586() throws Exception { + runTest("compiler/testData/diagnostics/tests/labels/kt4586.kt"); + } + + @Test + @TestMetadata("kt4603.kt") + public void testKt4603() throws Exception { + runTest("compiler/testData/diagnostics/tests/labels/kt4603.kt"); + } + + @Test + @TestMetadata("kt591.kt") + public void testKt591() throws Exception { + runTest("compiler/testData/diagnostics/tests/labels/kt591.kt"); + } + + @Test + @TestMetadata("labelReferencesInsideObjectExpressions.kt") + public void testLabelReferencesInsideObjectExpressions() throws Exception { + runTest("compiler/testData/diagnostics/tests/labels/labelReferencesInsideObjectExpressions.kt"); + } + + @Test + @TestMetadata("labeledFunctionLiteral.kt") + public void testLabeledFunctionLiteral() throws Exception { + runTest("compiler/testData/diagnostics/tests/labels/labeledFunctionLiteral.kt"); + } + + @Test + @TestMetadata("labelsMustBeNamed.kt") + public void testLabelsMustBeNamed() throws Exception { + runTest("compiler/testData/diagnostics/tests/labels/labelsMustBeNamed.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/lateinit") + @TestDataPath("$PROJECT_ROOT") + public class Lateinit { + @Test + public void testAllFilesPresentInLateinit() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/lateinit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("modifierApplicability_lv12.kt") + public void testModifierApplicability_lv12() throws Exception { + runTest("compiler/testData/diagnostics/tests/lateinit/modifierApplicability_lv12.kt"); + } + + @Test + @TestMetadata("NoInapplicableLateinitModifierForPropertyWithUnnresolvedType.kt") + public void testNoInapplicableLateinitModifierForPropertyWithUnnresolvedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/lateinit/NoInapplicableLateinitModifierForPropertyWithUnnresolvedType.kt"); + } + + @Test + @TestMetadata("setter.kt") + public void testSetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/lateinit/setter.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/lateinit/local") + @TestDataPath("$PROJECT_ROOT") + public class Local { + @Test + public void testAllFilesPresentInLocal() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/lateinit/local"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("inapplicableLateinitModifier.kt") + public void testInapplicableLateinitModifier() throws Exception { + runTest("compiler/testData/diagnostics/tests/lateinit/local/inapplicableLateinitModifier.kt"); + } + + @Test + @TestMetadata("localLateinit.kt") + public void testLocalLateinit() throws Exception { + runTest("compiler/testData/diagnostics/tests/lateinit/local/localLateinit.kt"); + } + + @Test + @TestMetadata("uninitialized.kt") + public void testUninitialized() throws Exception { + runTest("compiler/testData/diagnostics/tests/lateinit/local/uninitialized.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/library") + @TestDataPath("$PROJECT_ROOT") + public class Library { + @Test + public void testAllFilesPresentInLibrary() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/library"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("Collections.kt") + public void testCollections() throws Exception { + runTest("compiler/testData/diagnostics/tests/library/Collections.kt"); + } + + @Test + @TestMetadata("kt828.kt") + public void testKt828() throws Exception { + runTest("compiler/testData/diagnostics/tests/library/kt828.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/localClasses") + @TestDataPath("$PROJECT_ROOT") + public class LocalClasses { + @Test + public void testAllFilesPresentInLocalClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/localClasses"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("localAnnotationClass.kt") + public void testLocalAnnotationClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/localClasses/localAnnotationClass.kt"); + } + + @Test + @TestMetadata("localAnnotationClassError.kt") + public void testLocalAnnotationClassError() throws Exception { + runTest("compiler/testData/diagnostics/tests/localClasses/localAnnotationClassError.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/modifiers") + @TestDataPath("$PROJECT_ROOT") + public class Modifiers { + @Test + public void testAllFilesPresentInModifiers() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/modifiers"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("annotations.kt") + public void testAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/annotations.kt"); + } + + @Test + @TestMetadata("defaultModifier.kt") + public void testDefaultModifier() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/defaultModifier.kt"); + } + + @Test + @TestMetadata("IllegalModifiers.kt") + public void testIllegalModifiers() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt"); + } + + @Test + @TestMetadata("incompatibleVarianceModifiers.kt") + public void testIncompatibleVarianceModifiers() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/incompatibleVarianceModifiers.kt"); + } + + @Test + @TestMetadata("inlineParameters.kt") + public void testInlineParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/inlineParameters.kt"); + } + + @Test + @TestMetadata("internalInInterface.kt") + public void testInternalInInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/internalInInterface.kt"); + } + + @Test + @TestMetadata("modifierOnParameterInFunctionType.kt") + public void testModifierOnParameterInFunctionType() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/modifierOnParameterInFunctionType.kt"); + } + + @Test + @TestMetadata("NoLocalVisibility.kt") + public void testNoLocalVisibility() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/NoLocalVisibility.kt"); + } + + @Test + @TestMetadata("openInExpectInterface.kt") + public void testOpenInExpectInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/openInExpectInterface.kt"); + } + + @Test + @TestMetadata("openInInterface.kt") + public void testOpenInInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/openInInterface.kt"); + } + + @Test + @TestMetadata("primaryConstructorMissingBrackets.kt") + public void testPrimaryConstructorMissingBrackets() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/primaryConstructorMissingBrackets.kt"); + } + + @Test + @TestMetadata("primaryConstructorMissingKeyword.kt") + public void testPrimaryConstructorMissingKeyword() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/primaryConstructorMissingKeyword.kt"); + } + + @Test + @TestMetadata("privateInInterface.kt") + public void testPrivateInInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/privateInInterface.kt"); + } + + @Test + @TestMetadata("protected.kt") + public void testProtected() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/protected.kt"); + } + + @Test + @TestMetadata("redundantTargets.kt") + public void testRedundantTargets() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/redundantTargets.kt"); + } + + @Test + @TestMetadata("repeatedModifiers.kt") + public void testRepeatedModifiers() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/repeatedModifiers.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/modifiers/const") + @TestDataPath("$PROJECT_ROOT") + public class Const { + @Test + public void testAllFilesPresentInConst() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/modifiers/const"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("applicability.kt") + public void testApplicability() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/const/applicability.kt"); + } + + @Test + @TestMetadata("arrayInAnnotationArgumentType.kt") + public void testArrayInAnnotationArgumentType() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/const/arrayInAnnotationArgumentType.kt"); + } + + @Test + @TestMetadata("constInteraction.kt") + public void testConstInteraction() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/const/constInteraction.kt"); + } + + @Test + @TestMetadata("enumConstName_after.kt") + public void testEnumConstName_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/const/enumConstName_after.kt"); + } + + @Test + @TestMetadata("enumConstName_before.kt") + public void testEnumConstName_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/const/enumConstName_before.kt"); + } + + @Test + @TestMetadata("equals_after.kt") + public void testEquals_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/const/equals_after.kt"); + } + + @Test + @TestMetadata("equals_before.kt") + public void testEquals_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/const/equals_before.kt"); + } + + @Test + @TestMetadata("fromJava.kt") + public void testFromJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/const/fromJava.kt"); + } + + @Test + @TestMetadata("fromJavaSubclass.kt") + public void testFromJavaSubclass() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/const/fromJavaSubclass.kt"); + } + + @Test + @TestMetadata("ifConstVal_after.kt") + public void testIfConstVal_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/const/ifConstVal_after.kt"); + } + + @Test + @TestMetadata("ifConstVal_before.kt") + public void testIfConstVal_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/const/ifConstVal_before.kt"); + } + + @Test + @TestMetadata("kCallable_after.kt") + public void testKCallable_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/const/kCallable_after.kt"); + } + + @Test + @TestMetadata("kCallable_before.kt") + public void testKCallable_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/const/kCallable_before.kt"); + } + + @Test + @TestMetadata("kt12248.kt") + public void testKt12248() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/const/kt12248.kt"); + } + + @Test + @TestMetadata("kt15913.kt") + public void testKt15913() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/const/kt15913.kt"); + } + + @Test + @TestMetadata("stdlibConstFun.kt") + public void testStdlibConstFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/const/stdlibConstFun.kt"); + } + + @Test + @TestMetadata("stringConcatenationWithObject.kt") + public void testStringConcatenationWithObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/const/stringConcatenationWithObject.kt"); + } + + @Test + @TestMetadata("types.kt") + public void testTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/const/types.kt"); + } + + @Test + @TestMetadata("unsigned.kt") + public void testUnsigned() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/const/unsigned.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/modifiers/operatorInfix") + @TestDataPath("$PROJECT_ROOT") + public class OperatorInfix { + @Test + public void testAllFilesPresentInOperatorInfix() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/modifiers/operatorInfix"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("LocalFunctions.kt") + public void testLocalFunctions() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/operatorInfix/LocalFunctions.kt"); + } + + @Test + @TestMetadata("MemberFunctions.kt") + public void testMemberFunctions() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/operatorInfix/MemberFunctions.kt"); + } + + @Test + @TestMetadata("Simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/modifiers/operatorInfix/Simple.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/multimodule") + @TestDataPath("$PROJECT_ROOT") + public class Multimodule { + @Test + public void testAllFilesPresentInMultimodule() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("friendModule.kt") + public void testFriendModule() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/friendModule.kt"); + } + + @Test + @TestMetadata("friendModulePrivate.kt") + public void testFriendModulePrivate() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/friendModulePrivate.kt"); + } + + @Test + @TestMetadata("internal.kt") + public void testInternal() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/internal.kt"); + } + + @Test + @TestMetadata("kt14249.kt") + public void testKt14249() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/kt14249.kt"); + } + + @Test + @TestMetadata("packagePrivate.kt") + public void testPackagePrivate() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/packagePrivate.kt"); + } + + @Test + @TestMetadata("publishedApiInternal.kt") + public void testPublishedApiInternal() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/publishedApiInternal.kt"); + } + + @Test + @TestMetadata("redundantElseInWhen.kt") + public void testRedundantElseInWhen() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/redundantElseInWhen.kt"); + } + + @Test + @TestMetadata("samWithSuspendFunctionFromAnotherModule.kt") + public void testSamWithSuspendFunctionFromAnotherModule() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/samWithSuspendFunctionFromAnotherModule.kt"); + } + + @Test + @TestMetadata("varargConflict.kt") + public void testVarargConflict() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/varargConflict.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateClass") + @TestDataPath("$PROJECT_ROOT") + public class DuplicateClass { + @Test + public void testAllFilesPresentInDuplicateClass() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/duplicateClass"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("collectionMethodStub.kt") + public void testCollectionMethodStub() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateClass/collectionMethodStub.kt"); + } + + @Test + @TestMetadata("differentGenericArguments.kt") + public void testDifferentGenericArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateClass/differentGenericArguments.kt"); + } + + @Test + @TestMetadata("differentGenericArgumentsReversed.kt") + public void testDifferentGenericArgumentsReversed() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateClass/differentGenericArgumentsReversed.kt"); + } + + @Test + @TestMetadata("duplicateClass.kt") + public void testDuplicateClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateClass.kt"); + } + + @Test + @TestMetadata("duplicateNestedClasses.kt") + public void testDuplicateNestedClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateNestedClasses.kt"); + } + + @Test + @TestMetadata("duplicateSuperClass.kt") + public void testDuplicateSuperClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateSuperClass.kt"); + } + + @Test + @TestMetadata("genericArgumentNumberMismatch.kt") + public void testGenericArgumentNumberMismatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateClass/genericArgumentNumberMismatch.kt"); + } + + @Test + @TestMetadata("genericSuperClass.kt") + public void testGenericSuperClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateClass/genericSuperClass.kt"); + } + + @Test + @TestMetadata("inTheSameModuleWithUsage.kt") + public void testInTheSameModuleWithUsage() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateClass/inTheSameModuleWithUsage.kt"); + } + + @Test + @TestMetadata("inTheSameModuleWithUsageNoTypeAnnotation.kt") + public void testInTheSameModuleWithUsageNoTypeAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateClass/inTheSameModuleWithUsageNoTypeAnnotation.kt"); + } + + @Test + @TestMetadata("members.kt") + public void testMembers() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateClass/members.kt"); + } + + @Test + @TestMetadata("sameClassNameDifferentPackages.kt") + public void testSameClassNameDifferentPackages() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateClass/sameClassNameDifferentPackages.kt"); + } + + @Test + @TestMetadata("sameGenericArguments.kt") + public void testSameGenericArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateClass/sameGenericArguments.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod") + @TestDataPath("$PROJECT_ROOT") + public class DuplicateMethod { + @Test + public void testAllFilesPresentInDuplicateMethod() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/duplicateMethod"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("classGenericsInParams.kt") + public void testClassGenericsInParams() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParams.kt"); + } + + @Test + @TestMetadata("classGenericsInParamsBoundMismatch.kt") + public void testClassGenericsInParamsBoundMismatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParamsBoundMismatch.kt"); + } + + @Test + @TestMetadata("classGenericsInParamsIndexMismatch.kt") + public void testClassGenericsInParamsIndexMismatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParamsIndexMismatch.kt"); + } + + @Test + @TestMetadata("classGenericsInParamsNameMismatch.kt") + public void testClassGenericsInParamsNameMismatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParamsNameMismatch.kt"); + } + + @Test + @TestMetadata("classGenericsInReturnType.kt") + public void testClassGenericsInReturnType() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInReturnType.kt"); + } + + @Test + @TestMetadata("classVsFunctionGenericsInParamsMismatch.kt") + public void testClassVsFunctionGenericsInParamsMismatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classVsFunctionGenericsInParamsMismatch.kt"); + } + + @Test + @TestMetadata("covariantReturnTypes.kt") + public void testCovariantReturnTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/covariantReturnTypes.kt"); + } + + @Test + @TestMetadata("differenceInParamNames.kt") + public void testDifferenceInParamNames() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differenceInParamNames.kt"); + } + + @Test + @TestMetadata("differentGenericsInParams.kt") + public void testDifferentGenericsInParams() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differentGenericsInParams.kt"); + } + + @Test + @TestMetadata("differentNumberOfParams.kt") + public void testDifferentNumberOfParams() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differentNumberOfParams.kt"); + } + + @Test + @TestMetadata("differentReturnTypes.kt") + public void testDifferentReturnTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differentReturnTypes.kt"); + } + + @Test + @TestMetadata("extensionMatch.kt") + public void testExtensionMatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/extensionMatch.kt"); + } + + @Test + @TestMetadata("functionGenericsInParams.kt") + public void testFunctionGenericsInParams() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParams.kt"); + } + + @Test + @TestMetadata("functionGenericsInParamsBoundsMismatch.kt") + public void testFunctionGenericsInParamsBoundsMismatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsBoundsMismatch.kt"); + } + + @Test + @TestMetadata("functionGenericsInParamsEqNull.kt") + public void testFunctionGenericsInParamsEqNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsEqNull.kt"); + } + + @Test + @TestMetadata("functionGenericsInParamsNotIs.kt") + public void testFunctionGenericsInParamsNotIs() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsNotIs.kt"); + } + + @Test + @TestMetadata("functionGenericsInParamsReturnFooT.kt") + public void testFunctionGenericsInParamsReturnFooT() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsReturnFooT.kt"); + } + + @Test + @TestMetadata("functionGenericsInParamsReturnT.kt") + public void testFunctionGenericsInParamsReturnT() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsReturnT.kt"); + } + + @Test + @TestMetadata("incompleteCodeNoNoneApplicable.kt") + public void testIncompleteCodeNoNoneApplicable() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/incompleteCodeNoNoneApplicable.kt"); + } + + @Test + @TestMetadata("noGenericsInParams.kt") + public void testNoGenericsInParams() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/noGenericsInParams.kt"); + } + + @Test + @TestMetadata("noParams.kt") + public void testNoParams() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/noParams.kt"); + } + + @Test + @TestMetadata("sameGenericsInParams.kt") + public void testSameGenericsInParams() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/sameGenericsInParams.kt"); + } + + @Test + @TestMetadata("simpleWithInheritance.kt") + public void testSimpleWithInheritance() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/simpleWithInheritance.kt"); + } + + @Test + @TestMetadata("sinceKotlin.kt") + public void testSinceKotlin() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/sinceKotlin.kt"); + } + + @Test + @TestMetadata("substitutedGenericInParams.kt") + public void testSubstitutedGenericInParams() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/substitutedGenericInParams.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateSuper") + @TestDataPath("$PROJECT_ROOT") + public class DuplicateSuper { + @Test + public void testAllFilesPresentInDuplicateSuper() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/duplicateSuper"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("differentSuperTraits.kt") + public void testDifferentSuperTraits() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateSuper/differentSuperTraits.kt"); + } + + @Test + @TestMetadata("sameSuperTrait.kt") + public void testSameSuperTrait() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateSuper/sameSuperTrait.kt"); + } + + @Test + @TestMetadata("sameSuperTraitDifferentBounds.kt") + public void testSameSuperTraitDifferentBounds() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateSuper/sameSuperTraitDifferentBounds.kt"); + } + + @Test + @TestMetadata("sameSuperTraitGenerics.kt") + public void testSameSuperTraitGenerics() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/duplicateSuper/sameSuperTraitGenerics.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/multimodule/hiddenClass") + @TestDataPath("$PROJECT_ROOT") + public class HiddenClass { + @Test + public void testAllFilesPresentInHiddenClass() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/hiddenClass"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("deprecatedHiddenImportPriority.kt") + public void testDeprecatedHiddenImportPriority() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/hiddenClass/deprecatedHiddenImportPriority.kt"); + } + + @Test + @TestMetadata("deprecatedHiddenMultipleClasses.kt") + public void testDeprecatedHiddenMultipleClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/hiddenClass/deprecatedHiddenMultipleClasses.kt"); + } + + @Test + @TestMetadata("sinceKotlinImportPriority.kt") + public void testSinceKotlinImportPriority() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/hiddenClass/sinceKotlinImportPriority.kt"); + } + + @Test + @TestMetadata("sinceKotlinMultipleClasses.kt") + public void testSinceKotlinMultipleClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/multimodule/hiddenClass/sinceKotlinMultipleClasses.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/namedArguments") + @TestDataPath("$PROJECT_ROOT") + public class NamedArguments { + @Test + public void testAllFilesPresentInNamedArguments() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/namedArguments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("allowForJavaAnnotation.kt") + public void testAllowForJavaAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/tests/namedArguments/allowForJavaAnnotation.kt"); + } + + @Test + @TestMetadata("ambiguousNamedArguments1.kt") + public void testAmbiguousNamedArguments1() throws Exception { + runTest("compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArguments1.kt"); + } + + @Test + @TestMetadata("ambiguousNamedArguments2.kt") + public void testAmbiguousNamedArguments2() throws Exception { + runTest("compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArguments2.kt"); + } + + @Test + @TestMetadata("ambiguousNamedArgumentsWithGenerics1.kt") + public void testAmbiguousNamedArgumentsWithGenerics1() throws Exception { + runTest("compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArgumentsWithGenerics1.kt"); + } + + @Test + @TestMetadata("ambiguousNamedArgumentsWithGenerics2.kt") + public void testAmbiguousNamedArgumentsWithGenerics2() throws Exception { + runTest("compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArgumentsWithGenerics2.kt"); + } + + @Test + @TestMetadata("ambiguousNamedArgumentsWithGenerics3.kt") + public void testAmbiguousNamedArgumentsWithGenerics3() throws Exception { + runTest("compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArgumentsWithGenerics3.kt"); + } + + @Test + @TestMetadata("disallowForDelegationToJavaMethods.kt") + public void testDisallowForDelegationToJavaMethods() throws Exception { + runTest("compiler/testData/diagnostics/tests/namedArguments/disallowForDelegationToJavaMethods.kt"); + } + + @Test + @TestMetadata("disallowForFunctionTypes.kt") + public void testDisallowForFunctionTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/namedArguments/disallowForFunctionTypes.kt"); + } + + @Test + @TestMetadata("disallowForJavaConstructor.kt") + public void testDisallowForJavaConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/namedArguments/disallowForJavaConstructor.kt"); + } + + @Test + @TestMetadata("disallowForJavaMethods.kt") + public void testDisallowForJavaMethods() throws Exception { + runTest("compiler/testData/diagnostics/tests/namedArguments/disallowForJavaMethods.kt"); + } + + @Test + @TestMetadata("disallowForSamAdapterConstructor.kt") + public void testDisallowForSamAdapterConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterConstructor.kt"); + } + + @Test + @TestMetadata("disallowForSamAdapterFunction.kt") + public void testDisallowForSamAdapterFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterFunction.kt"); + } + + @Test + @TestMetadata("namedArgumentsAndDefaultValues.kt") + public void testNamedArgumentsAndDefaultValues() throws Exception { + runTest("compiler/testData/diagnostics/tests/namedArguments/namedArgumentsAndDefaultValues.kt"); + } + + @Test + @TestMetadata("namedArgumentsInOverloads.kt") + public void testNamedArgumentsInOverloads() throws Exception { + runTest("compiler/testData/diagnostics/tests/namedArguments/namedArgumentsInOverloads.kt"); + } + + @Test + @TestMetadata("namedArgumentsInOverrides.kt") + public void testNamedArgumentsInOverrides() throws Exception { + runTest("compiler/testData/diagnostics/tests/namedArguments/namedArgumentsInOverrides.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition") + @TestDataPath("$PROJECT_ROOT") + public class MixedNamedPosition { + @Test + public void testAllFilesPresentInMixedNamedPosition() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("defaults.kt") + public void testDefaults() throws Exception { + runTest("compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/defaults.kt"); + } + + @Test + @TestMetadata("disabledFeature.kt") + public void testDisabledFeature() throws Exception { + runTest("compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/disabledFeature.kt"); + } + + @Test + @TestMetadata("oldInference.kt") + public void testOldInference() throws Exception { + runTest("compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/oldInference.kt"); + } + + @Test + @TestMetadata("secondNamed.kt") + public void testSecondNamed() throws Exception { + runTest("compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/secondNamed.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/simple.kt"); + } + + @Test + @TestMetadata("varargs.kt") + public void testVarargs() throws Exception { + runTest("compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/varargs.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts") + @TestDataPath("$PROJECT_ROOT") + public class NullabilityAndSmartCasts { + @Test + public void testAllFilesPresentInNullabilityAndSmartCasts() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("AssertNotNull.kt") + public void testAssertNotNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/AssertNotNull.kt"); + } + + @Test + @TestMetadata("augmentedAssignment.kt") + public void testAugmentedAssignment() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/augmentedAssignment.kt"); + } + + @Test + @TestMetadata("dataFlowInfoAfterExclExcl.kt") + public void testDataFlowInfoAfterExclExcl() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/dataFlowInfoAfterExclExcl.kt"); + } + + @Test + @TestMetadata("equalityUnderNotNullCheck.kt") + public void testEqualityUnderNotNullCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/equalityUnderNotNullCheck.kt"); + } + + @Test + @TestMetadata("funcLiteralArgsInsideAmbiguity.kt") + public void testFuncLiteralArgsInsideAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/funcLiteralArgsInsideAmbiguity.kt"); + } + + @Test + @TestMetadata("funcLiteralArgsInsideUnresolvedFunction.kt") + public void testFuncLiteralArgsInsideUnresolvedFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/funcLiteralArgsInsideUnresolvedFunction.kt"); + } + + @Test + @TestMetadata("InfixCallNullability.kt") + public void testInfixCallNullability() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/InfixCallNullability.kt"); + } + + @Test + @TestMetadata("kt1270.kt") + public void testKt1270() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt1270.kt"); + } + + @Test + @TestMetadata("kt1680.kt") + public void testKt1680() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt1680.kt"); + } + + @Test + @TestMetadata("kt1778.kt") + public void testKt1778() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt1778.kt"); + } + + @Test + @TestMetadata("kt2109.kt") + public void testKt2109() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2109.kt"); + } + + @Test + @TestMetadata("kt2125.kt") + public void testKt2125() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2125.kt"); + } + + @Test + @TestMetadata("kt2146.kt") + public void testKt2146() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2146.kt"); + } + + @Test + @TestMetadata("kt2164.kt") + public void testKt2164() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2164.kt"); + } + + @Test + @TestMetadata("kt2176.kt") + public void testKt2176() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2176.kt"); + } + + @Test + @TestMetadata("kt2195.kt") + public void testKt2195() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2195.kt"); + } + + @Test + @TestMetadata("kt2212.kt") + public void testKt2212() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2212.kt"); + } + + @Test + @TestMetadata("kt2216.kt") + public void testKt2216() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2216.kt"); + } + + @Test + @TestMetadata("kt2223.kt") + public void testKt2223() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2223.kt"); + } + + @Test + @TestMetadata("kt2234.kt") + public void testKt2234() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2234.kt"); + } + + @Test + @TestMetadata("kt2336.kt") + public void testKt2336() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2336.kt"); + } + + @Test + @TestMetadata("kt244.kt") + public void testKt244() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt244.kt"); + } + + @Test + @TestMetadata("kt30734.kt") + public void testKt30734() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt30734.kt"); + } + + @Test + @TestMetadata("kt362.kt") + public void testKt362() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt362.kt"); + } + + @Test + @TestMetadata("noSenselessNullOnNullableType.kt") + public void testNoSenselessNullOnNullableType() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/noSenselessNullOnNullableType.kt"); + } + + @Test + @TestMetadata("noUnnecessaryNotNullAssertionOnErrorType.kt") + public void testNoUnnecessaryNotNullAssertionOnErrorType() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/noUnnecessaryNotNullAssertionOnErrorType.kt"); + } + + @Test + @TestMetadata("notnullTypesFromJavaWithSmartcast.kt") + public void testNotnullTypesFromJavaWithSmartcast() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/notnullTypesFromJavaWithSmartcast.kt"); + } + + @Test + @TestMetadata("NullableNothingIsExactlyNull.kt") + public void testNullableNothingIsExactlyNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/NullableNothingIsExactlyNull.kt"); + } + + @Test + @TestMetadata("nullableReceiverWithOverloadedMethod.kt") + public void testNullableReceiverWithOverloadedMethod() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/nullableReceiverWithOverloadedMethod.kt"); + } + + @Test + @TestMetadata("PreferExtensionsOnNullableReceiver.kt") + public void testPreferExtensionsOnNullableReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/PreferExtensionsOnNullableReceiver.kt"); + } + + @Test + @TestMetadata("QualifiedExpressionNullability.kt") + public void testQualifiedExpressionNullability() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/QualifiedExpressionNullability.kt"); + } + + @Test + @TestMetadata("ReceiverNullability.kt") + public void testReceiverNullability() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/ReceiverNullability.kt"); + } + + @Test + @TestMetadata("SenselessNullInWhen.kt") + public void testSenselessNullInWhen() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/SenselessNullInWhen.kt"); + } + + @Test + @TestMetadata("senslessComparisonWithNullOnTypeParameters.kt") + public void testSenslessComparisonWithNullOnTypeParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/senslessComparisonWithNullOnTypeParameters.kt"); + } + + @Test + @TestMetadata("smartCastReceiverWithGenerics.kt") + public void testSmartCastReceiverWithGenerics() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/smartCastReceiverWithGenerics.kt"); + } + + @Test + @TestMetadata("smartCastsAndBooleanExpressions.kt") + public void testSmartCastsAndBooleanExpressions() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/smartCastsAndBooleanExpressions.kt"); + } + + @Test + @TestMetadata("unnecessaryNotNullAssertion.kt") + public void testUnnecessaryNotNullAssertion() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/unnecessaryNotNullAssertion.kt"); + } + + @Test + @TestMetadata("unstableSmartcastWhenOpenGetterWithOverloading.kt") + public void testUnstableSmartcastWhenOpenGetterWithOverloading() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/unstableSmartcastWhenOpenGetterWithOverloading.kt"); + } + + @Test + @TestMetadata("unstableSmartcastWithOverloadedExtensions.kt") + public void testUnstableSmartcastWithOverloadedExtensions() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/unstableSmartcastWithOverloadedExtensions.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/nullableTypes") + @TestDataPath("$PROJECT_ROOT") + public class NullableTypes { + @Test + public void testAllFilesPresentInNullableTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/nullableTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("baseWithNullableUpperBound.kt") + public void testBaseWithNullableUpperBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullableTypes/baseWithNullableUpperBound.kt"); + } + + @Test + @TestMetadata("definitelyNotNullWithNullableBound.kt") + public void testDefinitelyNotNullWithNullableBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullableTypes/definitelyNotNullWithNullableBound.kt"); + } + + @Test + @TestMetadata("elvisOnUnit.kt") + public void testElvisOnUnit() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullableTypes/elvisOnUnit.kt"); + } + + @Test + @TestMetadata("inferenceFlexibleTToNullable.kt") + public void testInferenceFlexibleTToNullable() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullableTypes/inferenceFlexibleTToNullable.kt"); + } + + @Test + @TestMetadata("nullAssertOnTypeWithNullableUpperBound.kt") + public void testNullAssertOnTypeWithNullableUpperBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullableTypes/nullAssertOnTypeWithNullableUpperBound.kt"); + } + + @Test + @TestMetadata("nullableArgumentForIn.kt") + public void testNullableArgumentForIn() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentForIn.kt"); + } + + @Test + @TestMetadata("nullableArgumentToNonNullParameterPlatform.kt") + public void testNullableArgumentToNonNullParameterPlatform() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentToNonNullParameterPlatform.kt"); + } + + @Test + @TestMetadata("nullableArgumentToNonNullParameterSimple.kt") + public void testNullableArgumentToNonNullParameterSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentToNonNullParameterSimple.kt"); + } + + @Test + @TestMetadata("redundantNullable.kt") + public void testRedundantNullable() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullableTypes/redundantNullable.kt"); + } + + @Test + @TestMetadata("redundantNullableInSupertype.kt") + public void testRedundantNullableInSupertype() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullableTypes/redundantNullableInSupertype.kt"); + } + + @Test + @TestMetadata("safeAccessOnUnit.kt") + public void testSafeAccessOnUnit() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullableTypes/safeAccessOnUnit.kt"); + } + + @Test + @TestMetadata("safeCallOnNotNullableType.kt") + public void testSafeCallOnNotNullableType() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullableTypes/safeCallOnNotNullableType.kt"); + } + + @Test + @TestMetadata("safeCallOnTypeWithNullableUpperBound.kt") + public void testSafeCallOnTypeWithNullableUpperBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullableTypes/safeCallOnTypeWithNullableUpperBound.kt"); + } + + @Test + @TestMetadata("safeCallOperators.kt") + public void testSafeCallOperators() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullableTypes/safeCallOperators.kt"); + } + + @Test + @TestMetadata("safeCallWithInvoke.kt") + public void testSafeCallWithInvoke() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullableTypes/safeCallWithInvoke.kt"); + } + + @Test + @TestMetadata("takingNullabilityFromExplicitTypeArgmentsInsteadOfUsingFlexibleTypes.kt") + public void testTakingNullabilityFromExplicitTypeArgmentsInsteadOfUsingFlexibleTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullableTypes/takingNullabilityFromExplicitTypeArgmentsInsteadOfUsingFlexibleTypes.kt"); + } + + @Test + @TestMetadata("uselessElvis.kt") + public void testUselessElvis() throws Exception { + runTest("compiler/testData/diagnostics/tests/nullableTypes/uselessElvis.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/numbers") + @TestDataPath("$PROJECT_ROOT") + public class Numbers { + @Test + public void testAllFilesPresentInNumbers() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/numbers"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("characterIsNotANumber.kt") + public void testCharacterIsNotANumber() throws Exception { + runTest("compiler/testData/diagnostics/tests/numbers/characterIsNotANumber.kt"); + } + + @Test + @TestMetadata("doublesInSimpleConstraints.kt") + public void testDoublesInSimpleConstraints() throws Exception { + runTest("compiler/testData/diagnostics/tests/numbers/doublesInSimpleConstraints.kt"); + } + + @Test + @TestMetadata("intValuesOutOfRange.kt") + public void testIntValuesOutOfRange() throws Exception { + runTest("compiler/testData/diagnostics/tests/numbers/intValuesOutOfRange.kt"); + } + + @Test + @TestMetadata("integerLiteralWillChangeResolveInFunctionReturnPosition.kt") + public void testIntegerLiteralWillChangeResolveInFunctionReturnPosition() throws Exception { + runTest("compiler/testData/diagnostics/tests/numbers/integerLiteralWillChangeResolveInFunctionReturnPosition.kt"); + } + + @Test + @TestMetadata("kt41679.kt") + public void testKt41679() throws Exception { + runTest("compiler/testData/diagnostics/tests/numbers/kt41679.kt"); + } + + @Test + @TestMetadata("kt45970.kt") + public void testKt45970() throws Exception { + runTest("compiler/testData/diagnostics/tests/numbers/kt45970.kt"); + } + + @Test + @TestMetadata("kt47447.kt") + public void testKt47447() throws Exception { + runTest("compiler/testData/diagnostics/tests/numbers/kt47447.kt"); + } + + @Test + @TestMetadata("kt47729.kt") + public void testKt47729() throws Exception { + runTest("compiler/testData/diagnostics/tests/numbers/kt47729.kt"); + } + + @Test + @TestMetadata("kt47729_parenthesis.kt") + public void testKt47729_parenthesis() throws Exception { + runTest("compiler/testData/diagnostics/tests/numbers/kt47729_parenthesis.kt"); + } + + @Test + @TestMetadata("kt48361.kt") + public void testKt48361() throws Exception { + runTest("compiler/testData/diagnostics/tests/numbers/kt48361.kt"); + } + + @Test + @TestMetadata("literalReceiverWithIntegerValueType.kt") + public void testLiteralReceiverWithIntegerValueType() throws Exception { + runTest("compiler/testData/diagnostics/tests/numbers/literalReceiverWithIntegerValueType.kt"); + } + + @Test + @TestMetadata("newLiteralOperatorsResolution_warning.kt") + public void testNewLiteralOperatorsResolution_warning() throws Exception { + runTest("compiler/testData/diagnostics/tests/numbers/newLiteralOperatorsResolution_warning.kt"); + } + + @Test + @TestMetadata("numberAsUnionAndIntersection.kt") + public void testNumberAsUnionAndIntersection() throws Exception { + runTest("compiler/testData/diagnostics/tests/numbers/numberAsUnionAndIntersection.kt"); + } + + @Test + @TestMetadata("numbersInSimpleConstraints.kt") + public void testNumbersInSimpleConstraints() throws Exception { + runTest("compiler/testData/diagnostics/tests/numbers/numbersInSimpleConstraints.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/objects") + @TestDataPath("$PROJECT_ROOT") + public class Objects { + @Test + public void testAllFilesPresentInObjects() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/objects"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("invokeOnInnerObject.kt") + public void testInvokeOnInnerObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/invokeOnInnerObject.kt"); + } + + @Test + @TestMetadata("kt2240.kt") + public void testKt2240() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt2240.kt"); + } + + @Test + @TestMetadata("kt5527.kt") + public void testKt5527() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt5527.kt"); + } + + @Test + @TestMetadata("localObjectInsideObject.kt") + public void testLocalObjectInsideObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/localObjectInsideObject.kt"); + } + + @Test + @TestMetadata("localObjects.kt") + public void testLocalObjects() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/localObjects.kt"); + } + + @Test + @TestMetadata("nestedClassInAnonymousObject.kt") + public void testNestedClassInAnonymousObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/nestedClassInAnonymousObject.kt"); + } + + @Test + @TestMetadata("objectInsideFun.kt") + public void testObjectInsideFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/objectInsideFun.kt"); + } + + @Test + @TestMetadata("objectLiteralExpressionTypeMismatch.kt") + public void testObjectLiteralExpressionTypeMismatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/objectLiteralExpressionTypeMismatch.kt"); + } + + @Test + @TestMetadata("Objects.kt") + public void testObjects() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/Objects.kt"); + } + + @Test + @TestMetadata("ObjectsInheritance.kt") + public void testObjectsInheritance() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/ObjectsInheritance.kt"); + } + + @Test + @TestMetadata("ObjectsLocal.kt") + public void testObjectsLocal() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/ObjectsLocal.kt"); + } + + @Test + @TestMetadata("ObjectsNested.kt") + public void testObjectsNested() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/ObjectsNested.kt"); + } + + @Test + @TestMetadata("OpenInObject.kt") + public void testOpenInObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/OpenInObject.kt"); + } + + @Test + @TestMetadata("upperBoundViolated.kt") + public void testUpperBoundViolated() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/upperBoundViolated.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/objects/kt21515") + @TestDataPath("$PROJECT_ROOT") + public class Kt21515 { + @Test + public void testAllFilesPresentInKt21515() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/objects/kt21515"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("annotationConstructor.kt") + public void testAnnotationConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt21515/annotationConstructor.kt"); + } + + @Test + @TestMetadata("callableReferenceComplexCasesWithImportsOld.kt") + public void testCallableReferenceComplexCasesWithImportsOld() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt21515/callableReferenceComplexCasesWithImportsOld.kt"); + } + + @Test + @TestMetadata("callableReferencesComplexCasesWithQualificationOld.kt") + public void testCallableReferencesComplexCasesWithQualificationOld() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesComplexCasesWithQualificationOld.kt"); + } + + @Test + @TestMetadata("callableReferencesNew.kt") + public void testCallableReferencesNew() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesNew.kt"); + } + + @Test + @TestMetadata("callableReferencesOld.kt") + public void testCallableReferencesOld() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOld.kt"); + } + + @Test + @TestMetadata("callableReferencesOldComplexCases.kt") + public void testCallableReferencesOldComplexCases() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOldComplexCases.kt"); + } + + @Test + @TestMetadata("callableReferencesWithQualificationNew.kt") + public void testCallableReferencesWithQualificationNew() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesWithQualificationNew.kt"); + } + + @Test + @TestMetadata("callableReferencesWithQualificationOld.kt") + public void testCallableReferencesWithQualificationOld() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesWithQualificationOld.kt"); + } + + @Test + @TestMetadata("classifierFromCompanionObjectNew.kt") + public void testClassifierFromCompanionObjectNew() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectNew.kt"); + } + + @Test + @TestMetadata("classifierFromCompanionObjectOld.kt") + public void testClassifierFromCompanionObjectOld() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectOld.kt"); + } + + @Test + @TestMetadata("classifierFromCompanionObjectWithQualificationNew.kt") + public void testClassifierFromCompanionObjectWithQualificationNew() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectWithQualificationNew.kt"); + } + + @Test + @TestMetadata("classifierFromCompanionObjectWithQualificationOld.kt") + public void testClassifierFromCompanionObjectWithQualificationOld() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectWithQualificationOld.kt"); + } + + @Test + @TestMetadata("classifierIsVisibleByTwoPaths.kt") + public void testClassifierIsVisibleByTwoPaths() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt21515/classifierIsVisibleByTwoPaths.kt"); + } + + @Test + @TestMetadata("inheritedFromDeprecatedNew.kt") + public void testInheritedFromDeprecatedNew() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedNew.kt"); + } + + @Test + @TestMetadata("inheritedFromDeprecatedOld.kt") + public void testInheritedFromDeprecatedOld() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedOld.kt"); + } + + @Test + @TestMetadata("inheritedFromDeprecatedWithQualificationNew.kt") + public void testInheritedFromDeprecatedWithQualificationNew() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedWithQualificationNew.kt"); + } + + @Test + @TestMetadata("inheritedFromDeprecatedWithQualificationOld.kt") + public void testInheritedFromDeprecatedWithQualificationOld() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedWithQualificationOld.kt"); + } + + @Test + @TestMetadata("staticsFromJavaNew.kt") + public void testStaticsFromJavaNew() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt21515/staticsFromJavaNew.kt"); + } + + @Test + @TestMetadata("staticsFromJavaOld.kt") + public void testStaticsFromJavaOld() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt21515/staticsFromJavaOld.kt"); + } + + @Test + @TestMetadata("staticsFromJavaWithQualificationNew.kt") + public void testStaticsFromJavaWithQualificationNew() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt21515/staticsFromJavaWithQualificationNew.kt"); + } + + @Test + @TestMetadata("staticsFromJavaWithQualificationOld.kt") + public void testStaticsFromJavaWithQualificationOld() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt21515/staticsFromJavaWithQualificationOld.kt"); + } + + @Test + @TestMetadata("useDeprecatedConstructorNew.kt") + public void testUseDeprecatedConstructorNew() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorNew.kt"); + } + + @Test + @TestMetadata("useDeprecatedConstructorOld.kt") + public void testUseDeprecatedConstructorOld() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorOld.kt"); + } + + @Test + @TestMetadata("useDeprecatedConstructorWithQualificationNew.kt") + public void testUseDeprecatedConstructorWithQualificationNew() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorWithQualificationNew.kt"); + } + + @Test + @TestMetadata("useDeprecatedConstructorWithQualificationOld.kt") + public void testUseDeprecatedConstructorWithQualificationOld() throws Exception { + runTest("compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorWithQualificationOld.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/operatorRem") + @TestDataPath("$PROJECT_ROOT") + public class OperatorRem { + @Test + public void testAllFilesPresentInOperatorRem() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/operatorRem"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("DeprecatedModAssignOperatorConventions.kt") + public void testDeprecatedModAssignOperatorConventions() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorRem/DeprecatedModAssignOperatorConventions.kt"); + } + + @Test + @TestMetadata("deprecatedModConvention.kt") + public void testDeprecatedModConvention() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorRem/deprecatedModConvention.kt"); + } + + @Test + @TestMetadata("DeprecatedModOperatorConventions.kt") + public void testDeprecatedModOperatorConventions() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorRem/DeprecatedModOperatorConventions.kt"); + } + + @Test + @TestMetadata("doNotResolveToInapplicableRem.kt") + public void testDoNotResolveToInapplicableRem() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorRem/doNotResolveToInapplicableRem.kt"); + } + + @Test + @TestMetadata("forbiddenModOperatorConvention.kt") + public void testForbiddenModOperatorConvention() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorRem/forbiddenModOperatorConvention.kt"); + } + + @Test + @TestMetadata("modWithRemAssign.kt") + public void testModWithRemAssign() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorRem/modWithRemAssign.kt"); + } + + @Test + @TestMetadata("numberRemConversions.kt") + public void testNumberRemConversions() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorRem/numberRemConversions.kt"); + } + + @Test + @TestMetadata("operatorRem.kt") + public void testOperatorRem() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorRem/operatorRem.kt"); + } + + @Test + @TestMetadata("preferRemAsExtentionOverMod.kt") + public void testPreferRemAsExtentionOverMod() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorRem/preferRemAsExtentionOverMod.kt"); + } + + @Test + @TestMetadata("preferRemAsMemberOverMod.kt") + public void testPreferRemAsMemberOverMod() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorRem/preferRemAsMemberOverMod.kt"); + } + + @Test + @TestMetadata("preferRemFromCompanionObjectOverRem.kt") + public void testPreferRemFromCompanionObjectOverRem() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorRem/preferRemFromCompanionObjectOverRem.kt"); + } + + @Test + @TestMetadata("preferRemOverModInLocalFunctions.kt") + public void testPreferRemOverModInLocalFunctions() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorRem/preferRemOverModInLocalFunctions.kt"); + } + + @Test + @TestMetadata("preferRemWithImplicitReceivers.kt") + public void testPreferRemWithImplicitReceivers() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorRem/preferRemWithImplicitReceivers.kt"); + } + + @Test + @TestMetadata("prefereRemAsExtensionOverMemberMod.kt") + public void testPrefereRemAsExtensionOverMemberMod() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorRem/prefereRemAsExtensionOverMemberMod.kt"); + } + + @Test + @TestMetadata("remAndRemAssignAmbiguity.kt") + public void testRemAndRemAssignAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorRem/remAndRemAssignAmbiguity.kt"); + } + + @Test + @TestMetadata("remWithModAndModAssign.kt") + public void testRemWithModAndModAssign() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorRem/remWithModAndModAssign.kt"); + } + + @Test + @TestMetadata("remWithModAssign.kt") + public void testRemWithModAssign() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorRem/remWithModAssign.kt"); + } + + @Test + @TestMetadata("resolveModIfRemIsHidden.kt") + public void testResolveModIfRemIsHidden() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorRem/resolveModIfRemIsHidden.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/operatorsOverloading") + @TestDataPath("$PROJECT_ROOT") + public class OperatorsOverloading { + @Test + public void testAllFilesPresentInOperatorsOverloading() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/operatorsOverloading"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("AssignOperatorAmbiguity.kt") + public void testAssignOperatorAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorsOverloading/AssignOperatorAmbiguity.kt"); + } + + @Test + @TestMetadata("AssignmentOperations.kt") + public void testAssignmentOperations() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorsOverloading/AssignmentOperations.kt"); + } + + @Test + @TestMetadata("assignmentOperationsCheckReturnType.kt") + public void testAssignmentOperationsCheckReturnType() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorsOverloading/assignmentOperationsCheckReturnType.kt"); + } + + @Test + @TestMetadata("augmentedAssignForJavaSyntheticProperty.kt") + public void testAugmentedAssignForJavaSyntheticProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorsOverloading/augmentedAssignForJavaSyntheticProperty.kt"); + } + + @Test + @TestMetadata("compareToNullable.kt") + public void testCompareToNullable() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorsOverloading/compareToNullable.kt"); + } + + @Test + @TestMetadata("EqualsOperatorOverrideHierarchies.kt") + public void testEqualsOperatorOverrideHierarchies() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorsOverloading/EqualsOperatorOverrideHierarchies.kt"); + } + + @Test + @TestMetadata("incForAssignmentSmartCast.kt") + public void testIncForAssignmentSmartCast() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorsOverloading/incForAssignmentSmartCast.kt"); + } + + @Test + @TestMetadata("InconsistentGetSet.kt") + public void testInconsistentGetSet() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorsOverloading/InconsistentGetSet.kt"); + } + + @Test + @TestMetadata("IteratorAmbiguity.kt") + public void testIteratorAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorsOverloading/IteratorAmbiguity.kt"); + } + + @Test + @TestMetadata("kt1028.kt") + public void testKt1028() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorsOverloading/kt1028.kt"); + } + + @Test + @TestMetadata("kt11300.kt") + public void testKt11300() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorsOverloading/kt11300.kt"); + } + + @Test + @TestMetadata("kt13330.kt") + public void testKt13330() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorsOverloading/kt13330.kt"); + } + + @Test + @TestMetadata("kt13349.kt") + public void testKt13349() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorsOverloading/kt13349.kt"); + } + + @Test + @TestMetadata("kt3450.kt") + public void testKt3450() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorsOverloading/kt3450.kt"); + } + + @Test + @TestMetadata("kt45503_1.kt") + public void testKt45503_1() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorsOverloading/kt45503_1.kt"); + } + + @Test + @TestMetadata("kt45503_2.kt") + public void testKt45503_2() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorsOverloading/kt45503_2.kt"); + } + + @Test + @TestMetadata("kt45503_3.kt") + public void testKt45503_3() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorsOverloading/kt45503_3.kt"); + } + + @Test + @TestMetadata("plusAssignOnArray.kt") + public void testPlusAssignOnArray() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorsOverloading/plusAssignOnArray.kt"); + } + + @Test + @TestMetadata("plusAssignOnLocal.kt") + public void testPlusAssignOnLocal() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorsOverloading/plusAssignOnLocal.kt"); + } + + @Test + @TestMetadata("plusAssignOnProperty.kt") + public void testPlusAssignOnProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorsOverloading/plusAssignOnProperty.kt"); + } + + @Test + @TestMetadata("plusAssignOnVarAndCollections.kt") + public void testPlusAssignOnVarAndCollections() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorsOverloading/plusAssignOnVarAndCollections.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/operatorsOverloading/until") + @TestDataPath("$PROJECT_ROOT") + public class Until { + @Test + public void testAllFilesPresentInUntil() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/operatorsOverloading/until"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("custom.kt") + public void testCustom() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorsOverloading/until/custom.kt"); + } + + @Test + @TestMetadata("customDefault.kt") + public void testCustomDefault() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorsOverloading/until/customDefault.kt"); + } + + @Test + @TestMetadata("customDisabled.kt") + public void testCustomDisabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorsOverloading/until/customDisabled.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/operatorsOverloading/until/simple.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/overload") + @TestDataPath("$PROJECT_ROOT") + public class Overload { + @Test + public void testAllFilesPresentInOverload() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/overload"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("ConflictingOlverloadsGenericFunctions.kt") + public void testConflictingOlverloadsGenericFunctions() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/ConflictingOlverloadsGenericFunctions.kt"); + } + + @Test + @TestMetadata("ConflictingOverloadsFunsDifferentReturnInClass.kt") + public void testConflictingOverloadsFunsDifferentReturnInClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/ConflictingOverloadsFunsDifferentReturnInClass.kt"); + } + + @Test + @TestMetadata("ConflictingOverloadsFunsDifferentReturnInPackage.kt") + public void testConflictingOverloadsFunsDifferentReturnInPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/ConflictingOverloadsFunsDifferentReturnInPackage.kt"); + } + + @Test + @TestMetadata("ConflictingOverloadsIdenticalExtFunsInPackage.kt") + public void testConflictingOverloadsIdenticalExtFunsInPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/ConflictingOverloadsIdenticalExtFunsInPackage.kt"); + } + + @Test + @TestMetadata("ConflictingOverloadsIdenticalFunsInClass.kt") + public void testConflictingOverloadsIdenticalFunsInClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/ConflictingOverloadsIdenticalFunsInClass.kt"); + } + + @Test + @TestMetadata("ConflictingOverloadsIdenticalFunsTPInClass.kt") + public void testConflictingOverloadsIdenticalFunsTPInClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/ConflictingOverloadsIdenticalFunsTPInClass.kt"); + } + + @Test + @TestMetadata("ConflictingOverloadsIdenticalValsInClass.kt") + public void testConflictingOverloadsIdenticalValsInClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/ConflictingOverloadsIdenticalValsInClass.kt"); + } + + @Test + @TestMetadata("ConflictingOverloadsValsDifferentTypeInClass.kt") + public void testConflictingOverloadsValsDifferentTypeInClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/ConflictingOverloadsValsDifferentTypeInClass.kt"); + } + + @Test + @TestMetadata("ConstructorVsFunOverload.kt") + public void testConstructorVsFunOverload() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/ConstructorVsFunOverload.kt"); + } + + @Test + @TestMetadata("defaultParameters.kt") + public void testDefaultParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/defaultParameters.kt"); + } + + @Test + @TestMetadata("disambiguateByFailedAbstractClassCheck.kt") + public void testDisambiguateByFailedAbstractClassCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/disambiguateByFailedAbstractClassCheck.kt"); + } + + @Test + @TestMetadata("doubleWinsOverFloat.kt") + public void testDoubleWinsOverFloat() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/doubleWinsOverFloat.kt"); + } + + @Test + @TestMetadata("EmptyArgumentListInLambda.kt") + public void testEmptyArgumentListInLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/EmptyArgumentListInLambda.kt"); + } + + @Test + @TestMetadata("ExtFunDifferentReceiver.kt") + public void testExtFunDifferentReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/ExtFunDifferentReceiver.kt"); + } + + @Test + @TestMetadata("FunNoConflictInDifferentPackages.kt") + public void testFunNoConflictInDifferentPackages() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/FunNoConflictInDifferentPackages.kt"); + } + + @Test + @TestMetadata("kt10939.kt") + public void testKt10939() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/kt10939.kt"); + } + + @Test + @TestMetadata("kt1998.kt") + public void testKt1998() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/kt1998.kt"); + } + + @Test + @TestMetadata("kt2493.kt") + public void testKt2493() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/kt2493.kt"); + } + + @Test + @TestMetadata("kt7068.kt") + public void testKt7068() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/kt7068.kt"); + } + + @Test + @TestMetadata("kt7068_2.kt") + public void testKt7068_2() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/kt7068_2.kt"); + } + + @Test + @TestMetadata("kt7440.kt") + public void testKt7440() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/kt7440.kt"); + } + + @Test + @TestMetadata("LocalFunctions.kt") + public void testLocalFunctions() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/LocalFunctions.kt"); + } + + @Test + @TestMetadata("onlyPrivateOverloadsDiagnostic.kt") + public void testOnlyPrivateOverloadsDiagnostic() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/onlyPrivateOverloadsDiagnostic.kt"); + } + + @Test + @TestMetadata("OverloadFunRegularAndExt.kt") + public void testOverloadFunRegularAndExt() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/OverloadFunRegularAndExt.kt"); + } + + @Test + @TestMetadata("OverloadVarAndFunInClass.kt") + public void testOverloadVarAndFunInClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/OverloadVarAndFunInClass.kt"); + } + + @Test + @TestMetadata("overloadsFromCurrentAndSuperClass.kt") + public void testOverloadsFromCurrentAndSuperClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/overloadsFromCurrentAndSuperClass.kt"); + } + + @Test + @TestMetadata("overloadsFromCurrentAndSuperClassWithReturnType.kt") + public void testOverloadsFromCurrentAndSuperClassWithReturnType() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/overloadsFromCurrentAndSuperClassWithReturnType.kt"); + } + + @Test + @TestMetadata("SyntheticAndNotSynthetic.kt") + public void testSyntheticAndNotSynthetic() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/SyntheticAndNotSynthetic.kt"); + } + + @Test + @TestMetadata("TypeParameterMultipleBounds.kt") + public void testTypeParameterMultipleBounds() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/TypeParameterMultipleBounds.kt"); + } + + @Test + @TestMetadata("UnsubstitutedJavaGenetics.kt") + public void testUnsubstitutedJavaGenetics() throws Exception { + runTest("compiler/testData/diagnostics/tests/overload/UnsubstitutedJavaGenetics.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/override") + @TestDataPath("$PROJECT_ROOT") + public class Override { + @Test + @TestMetadata("AbstractFunImplemented.kt") + public void testAbstractFunImplemented() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/AbstractFunImplemented.kt"); + } + + @Test + @TestMetadata("AbstractFunNotImplemented.kt") + public void testAbstractFunNotImplemented() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/AbstractFunNotImplemented.kt"); + } + + @Test + @TestMetadata("AbstractValImplemented.kt") + public void testAbstractValImplemented() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/AbstractValImplemented.kt"); + } + + @Test + @TestMetadata("AbstractValNotImplemented.kt") + public void testAbstractValNotImplemented() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/AbstractValNotImplemented.kt"); + } + + @Test + @TestMetadata("AbstractVarImplemented.kt") + public void testAbstractVarImplemented() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/AbstractVarImplemented.kt"); + } + + @Test + @TestMetadata("AbstractVarNotImplemented.kt") + public void testAbstractVarNotImplemented() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/AbstractVarNotImplemented.kt"); + } + + @Test + public void testAllFilesPresentInOverride() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/override"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("AllPrivateFromSuperTypes.kt") + public void testAllPrivateFromSuperTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/AllPrivateFromSuperTypes.kt"); + } + + @Test + @TestMetadata("ComplexValRedeclaration.kt") + public void testComplexValRedeclaration() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/ComplexValRedeclaration.kt"); + } + + @Test + @TestMetadata("ConflictingFunctionSignatureFromSuperclass.kt") + public void testConflictingFunctionSignatureFromSuperclass() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/ConflictingFunctionSignatureFromSuperclass.kt"); + } + + @Test + @TestMetadata("ConflictingPropertySignatureFromSuperclass.kt") + public void testConflictingPropertySignatureFromSuperclass() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/ConflictingPropertySignatureFromSuperclass.kt"); + } + + @Test + @TestMetadata("DefaultParameterValueInOverride.kt") + public void testDefaultParameterValueInOverride() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/DefaultParameterValueInOverride.kt"); + } + + @Test + @TestMetadata("DefaultParameterValues-NoErrorsWhenInheritingFromOneTypeTwice.kt") + public void testDefaultParameterValues_NoErrorsWhenInheritingFromOneTypeTwice() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/DefaultParameterValues-NoErrorsWhenInheritingFromOneTypeTwice.kt"); + } + + @Test + @TestMetadata("Delegation.kt") + public void testDelegation() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/Delegation.kt"); + } + + @Test + @TestMetadata("DelegationFun.kt") + public void testDelegationFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/DelegationFun.kt"); + } + + @Test + @TestMetadata("DelegationVal.kt") + public void testDelegationVal() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/DelegationVal.kt"); + } + + @Test + @TestMetadata("DelegationVar.kt") + public void testDelegationVar() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/DelegationVar.kt"); + } + + @Test + @TestMetadata("diamondWithDiagonal.kt") + public void testDiamondWithDiagonal() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/diamondWithDiagonal.kt"); + } + + @Test + @TestMetadata("DuplicateMethod.kt") + public void testDuplicateMethod() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/DuplicateMethod.kt"); + } + + @Test + @TestMetadata("EqualityOfIntersectionTypes.kt") + public void testEqualityOfIntersectionTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/EqualityOfIntersectionTypes.kt"); + } + + @Test + @TestMetadata("ExtendFunctionClass.kt") + public void testExtendFunctionClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/ExtendFunctionClass.kt"); + } + + @Test + @TestMetadata("fakeEquals.kt") + public void testFakeEquals() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/fakeEquals.kt"); + } + + @Test + @TestMetadata("FakeOverrideAbstractAndNonAbstractFun.kt") + public void testFakeOverrideAbstractAndNonAbstractFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/FakeOverrideAbstractAndNonAbstractFun.kt"); + } + + @Test + @TestMetadata("FakeOverrideDifferentDeclarationSignatures.kt") + public void testFakeOverrideDifferentDeclarationSignatures() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/FakeOverrideDifferentDeclarationSignatures.kt"); + } + + @Test + @TestMetadata("FakeOverrideModality1.kt") + public void testFakeOverrideModality1() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/FakeOverrideModality1.kt"); + } + + @Test + @TestMetadata("FakeOverrideModality2.kt") + public void testFakeOverrideModality2() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/FakeOverrideModality2.kt"); + } + + @Test + @TestMetadata("FakeOverrideModality3.kt") + public void testFakeOverrideModality3() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/FakeOverrideModality3.kt"); + } + + @Test + @TestMetadata("Generics.kt") + public void testGenerics() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/Generics.kt"); + } + + @Test + @TestMetadata("InheritingJavaClassWithRawTypeInOverrideSignature.kt") + public void testInheritingJavaClassWithRawTypeInOverrideSignature() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/InheritingJavaClassWithRawTypeInOverrideSignature.kt"); + } + + @Test + @TestMetadata("InternalPotentialOverride.kt") + public void testInternalPotentialOverride() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/InternalPotentialOverride.kt"); + } + + @Test + @TestMetadata("InvisiblePotentialOverride.kt") + public void testInvisiblePotentialOverride() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/InvisiblePotentialOverride.kt"); + } + + @Test + @TestMetadata("kt12358.kt") + public void testKt12358() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/kt12358.kt"); + } + + @Test + @TestMetadata("kt12467.kt") + public void testKt12467() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/kt12467.kt"); + } + + @Test + @TestMetadata("kt12482.kt") + public void testKt12482() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/kt12482.kt"); + } + + @Test + @TestMetadata("kt1862.kt") + public void testKt1862() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/kt1862.kt"); + } + + @Test + @TestMetadata("kt2052.kt") + public void testKt2052() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/kt2052.kt"); + } + + @Test + @TestMetadata("kt2491.kt") + public void testKt2491() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/kt2491.kt"); + } + + @Test + @TestMetadata("kt4763.kt") + public void testKt4763() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/kt4763.kt"); + } + + @Test + @TestMetadata("kt4763property.kt") + public void testKt4763property() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/kt4763property.kt"); + } + + @Test + @TestMetadata("kt4785.kt") + public void testKt4785() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/kt4785.kt"); + } + + @Test + @TestMetadata("kt53408.kt") + public void testKt53408() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/kt53408.kt"); + } + + @Test + @TestMetadata("kt6014.kt") + public void testKt6014() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/kt6014.kt"); + } + + @Test + @TestMetadata("kt880.kt") + public void testKt880() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/kt880.kt"); + } + + @Test + @TestMetadata("kt8990.kt") + public void testKt8990() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/kt8990.kt"); + } + + @Test + @TestMetadata("manyImplFromOneJavaInterfaceWithDelegation.kt") + public void testManyImplFromOneJavaInterfaceWithDelegation() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/manyImplFromOneJavaInterfaceWithDelegation.kt"); + } + + @Test + @TestMetadata("manyImplFromOneKotlinInterfaceWithDelegation.kt") + public void testManyImplFromOneKotlinInterfaceWithDelegation() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/manyImplFromOneKotlinInterfaceWithDelegation.kt"); + } + + @Test + @TestMetadata("MissingDelegate.kt") + public void testMissingDelegate() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/MissingDelegate.kt"); + } + + @Test + @TestMetadata("MultipleDefaultParametersInSupertypes.kt") + public void testMultipleDefaultParametersInSupertypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/MultipleDefaultParametersInSupertypes.kt"); + } + + @Test + @TestMetadata("MultipleDefaultParametersInSupertypesNoOverride.kt") + public void testMultipleDefaultParametersInSupertypesNoOverride() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/MultipleDefaultParametersInSupertypesNoOverride.kt"); + } + + @Test + @TestMetadata("MultipleDefaultsAndNamesInSupertypes.kt") + public void testMultipleDefaultsAndNamesInSupertypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/MultipleDefaultsAndNamesInSupertypes.kt"); + } + + @Test + @TestMetadata("MultipleDefaultsInSupertypesNoExplicitOverride.kt") + public void testMultipleDefaultsInSupertypesNoExplicitOverride() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/MultipleDefaultsInSupertypesNoExplicitOverride.kt"); + } + + @Test + @TestMetadata("NonGenerics.kt") + public void testNonGenerics() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/NonGenerics.kt"); + } + + @Test + @TestMetadata("ObjectDelegationManyImpl.kt") + public void testObjectDelegationManyImpl() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/ObjectDelegationManyImpl.kt"); + } + + @Test + @TestMetadata("overrideMemberFromFinalClass.kt") + public void testOverrideMemberFromFinalClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/overrideMemberFromFinalClass.kt"); + } + + @Test + @TestMetadata("OverrideWithErrors.kt") + public void testOverrideWithErrors() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/OverrideWithErrors.kt"); + } + + @Test + @TestMetadata("OverridingFinalMember.kt") + public void testOverridingFinalMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/OverridingFinalMember.kt"); + } + + @Test + @TestMetadata("ParameterDefaultValues-DefaultValueFromOnlyOneSupertype.kt") + public void testParameterDefaultValues_DefaultValueFromOnlyOneSupertype() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/ParameterDefaultValues-DefaultValueFromOnlyOneSupertype.kt"); + } + + @Test + @TestMetadata("ParentInheritsManyImplementations.kt") + public void testParentInheritsManyImplementations() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/ParentInheritsManyImplementations.kt"); + } + + @Test + @TestMetadata("PropertyInConstructor.kt") + public void testPropertyInConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/PropertyInConstructor.kt"); + } + + @Test + @TestMetadata("ProtectedAndPrivateFromSupertypes.kt") + public void testProtectedAndPrivateFromSupertypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/ProtectedAndPrivateFromSupertypes.kt"); + } + + @Test + @TestMetadata("SuspiciousCase1.kt") + public void testSuspiciousCase1() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/SuspiciousCase1.kt"); + } + + @Test + @TestMetadata("ToAbstractMembersFromSuper-kt1996.kt") + public void testToAbstractMembersFromSuper_kt1996() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/ToAbstractMembersFromSuper-kt1996.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/override/clashesOnInheritance") + @TestDataPath("$PROJECT_ROOT") + public class ClashesOnInheritance { + @Test + public void testAllFilesPresentInClashesOnInheritance() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/override/clashesOnInheritance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("covariantOverrides.kt") + public void testCovariantOverrides() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/clashesOnInheritance/covariantOverrides.kt"); + } + + @Test + @TestMetadata("flexibleReturnType.kt") + public void testFlexibleReturnType() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/clashesOnInheritance/flexibleReturnType.kt"); + } + + @Test + @TestMetadata("flexibleReturnTypeIn.kt") + public void testFlexibleReturnTypeIn() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/clashesOnInheritance/flexibleReturnTypeIn.kt"); + } + + @Test + @TestMetadata("flexibleReturnTypeList.kt") + public void testFlexibleReturnTypeList() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/clashesOnInheritance/flexibleReturnTypeList.kt"); + } + + @Test + @TestMetadata("genericWithUpperBound.kt") + public void testGenericWithUpperBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/clashesOnInheritance/genericWithUpperBound.kt"); + } + + @Test + @TestMetadata("kt13355.kt") + public void testKt13355() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/clashesOnInheritance/kt13355.kt"); + } + + @Test + @TestMetadata("kt13355viaJava.kt") + public void testKt13355viaJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/clashesOnInheritance/kt13355viaJava.kt"); + } + + @Test + @TestMetadata("kt9550.kt") + public void testKt9550() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/clashesOnInheritance/kt9550.kt"); + } + + @Test + @TestMetadata("returnTypeMismatch.kt") + public void testReturnTypeMismatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/clashesOnInheritance/returnTypeMismatch.kt"); + } + + @Test + @TestMetadata("unrelatedInherited.kt") + public void testUnrelatedInherited() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/clashesOnInheritance/unrelatedInherited.kt"); + } + + @Test + @TestMetadata("valTypeMismatch.kt") + public void testValTypeMismatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/clashesOnInheritance/valTypeMismatch.kt"); + } + + @Test + @TestMetadata("varTypeMismatch.kt") + public void testVarTypeMismatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/clashesOnInheritance/varTypeMismatch.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/override/derivedClasses") + @TestDataPath("$PROJECT_ROOT") + public class DerivedClasses { + @Test + public void testAllFilesPresentInDerivedClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/override/derivedClasses"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("Constructor.kt") + public void testConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/derivedClasses/Constructor.kt"); + } + + @Test + @TestMetadata("DelegatedConstructor.kt") + public void testDelegatedConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/derivedClasses/DelegatedConstructor.kt"); + } + + @Test + @TestMetadata("EnumValues.kt") + public void testEnumValues() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/derivedClasses/EnumValues.kt"); + } + + @Test + @TestMetadata("Instance.kt") + public void testInstance() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/derivedClasses/Instance.kt"); + } + + @Test + @TestMetadata("StaticFieldFromJava.kt") + public void testStaticFieldFromJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/derivedClasses/StaticFieldFromJava.kt"); + } + + @Test + @TestMetadata("StaticMethodFromJava.kt") + public void testStaticMethodFromJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/derivedClasses/StaticMethodFromJava.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/override/parameterNames") + @TestDataPath("$PROJECT_ROOT") + public class ParameterNames { + @Test + public void testAllFilesPresentInParameterNames() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/override/parameterNames"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("changeOnOverrideDiagnostic.kt") + public void testChangeOnOverrideDiagnostic() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/parameterNames/changeOnOverrideDiagnostic.kt"); + } + + @Test + @TestMetadata("differentNamesInSupertypesDiagnostic.kt") + public void testDifferentNamesInSupertypesDiagnostic() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/parameterNames/differentNamesInSupertypesDiagnostic.kt"); + } + + @Test + @TestMetadata("invokeInFunctionClass.kt") + public void testInvokeInFunctionClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/parameterNames/invokeInFunctionClass.kt"); + } + + @Test + @TestMetadata("jjkHierarchy.kt") + public void testJjkHierarchy() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/parameterNames/jjkHierarchy.kt"); + } + + @Test + @TestMetadata("kjkHierarchy.kt") + public void testKjkHierarchy() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/parameterNames/kjkHierarchy.kt"); + } + + @Test + @TestMetadata("kjkWithSeveralSupers.kt") + public void testKjkWithSeveralSupers() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/parameterNames/kjkWithSeveralSupers.kt"); + } + + @Test + @TestMetadata("kotlinInheritsBothJavaAndKotlin.kt") + public void testKotlinInheritsBothJavaAndKotlin() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/parameterNames/kotlinInheritsBothJavaAndKotlin.kt"); + } + + @Test + @TestMetadata("kotlinInheritsJava.kt") + public void testKotlinInheritsJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/parameterNames/kotlinInheritsJava.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/override/typeParameters") + @TestDataPath("$PROJECT_ROOT") + public class TypeParameters { + @Test + public void testAllFilesPresentInTypeParameters() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/override/typeParameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("classAndTwoInterfaceBounds.kt") + public void testClassAndTwoInterfaceBounds() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/typeParameters/classAndTwoInterfaceBounds.kt"); + } + + @Test + @TestMetadata("differentSetsOfBounds.kt") + public void testDifferentSetsOfBounds() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/typeParameters/differentSetsOfBounds.kt"); + } + + @Test + @TestMetadata("kt9850.kt") + public void testKt9850() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/typeParameters/kt9850.kt"); + } + + @Test + @TestMetadata("simpleVisitorTwoAccepts.kt") + public void testSimpleVisitorTwoAccepts() throws Exception { + runTest("compiler/testData/diagnostics/tests/override/typeParameters/simpleVisitorTwoAccepts.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/parenthesizedTypes") + @TestDataPath("$PROJECT_ROOT") + public class ParenthesizedTypes { + @Test + public void testAllFilesPresentInParenthesizedTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/parenthesizedTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("annotationsOnNullableParenthesizedTypes.kt") + public void testAnnotationsOnNullableParenthesizedTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/parenthesizedTypes/annotationsOnNullableParenthesizedTypes.kt"); + } + + @Test + @TestMetadata("annotationsOnParenthesizedTypes.kt") + public void testAnnotationsOnParenthesizedTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/parenthesizedTypes/annotationsOnParenthesizedTypes.kt"); + } + + @Test + @TestMetadata("splitModifierList.kt") + public void testSplitModifierList() throws Exception { + runTest("compiler/testData/diagnostics/tests/parenthesizedTypes/splitModifierList.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/platformTypes") + @TestDataPath("$PROJECT_ROOT") + public class PlatformTypes { + @Test + public void testAllFilesPresentInPlatformTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("delegateByComplexInheritance.kt") + public void testDelegateByComplexInheritance() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/delegateByComplexInheritance.kt"); + } + + @Test + @TestMetadata("dereference.kt") + public void testDereference() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/dereference.kt"); + } + + @Test + @TestMetadata("elvis.kt") + public void testElvis() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/elvis.kt"); + } + + @Test + @TestMetadata("getParentOfType.kt") + public void testGetParentOfType() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/getParentOfType.kt"); + } + + @Test + @TestMetadata("inference.kt") + public void testInference() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/inference.kt"); + } + + @Test + @TestMetadata("intVsIntegerAmbiguity.kt") + public void testIntVsIntegerAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/intVsIntegerAmbiguity.kt"); + } + + @Test + @TestMetadata("javaEmptyList.kt") + public void testJavaEmptyList() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/javaEmptyList.kt"); + } + + @Test + @TestMetadata("javaMappedCtors.kt") + public void testJavaMappedCtors() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/javaMappedCtors.kt"); + } + + @Test + @TestMetadata("kt50877.kt") + public void testKt50877() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/kt50877.kt"); + } + + @Test + @TestMetadata("methodTypeParameterDefaultBound.kt") + public void testMethodTypeParameterDefaultBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/methodTypeParameterDefaultBound.kt"); + } + + @Test + @TestMetadata("noAnnotationInClassPath.kt") + public void testNoAnnotationInClassPath() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/noAnnotationInClassPath.kt"); + } + + @Test + @TestMetadata("nullableTypeArgument.kt") + public void testNullableTypeArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullableTypeArgument.kt"); + } + + @Test + @TestMetadata("override.kt") + public void testOverride() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/override.kt"); + } + + @Test + @TestMetadata("propagateFlexibilityFromOtherConstraints.kt") + public void testPropagateFlexibilityFromOtherConstraints() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/propagateFlexibilityFromOtherConstraints.kt"); + } + + @Test + @TestMetadata("rawOverrides.kt") + public void testRawOverrides() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawOverrides.kt"); + } + + @Test + @TestMetadata("rawSamOverrides.kt") + public void testRawSamOverrides() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawSamOverrides.kt"); + } + + @Test + @TestMetadata("safeCall.kt") + public void testSafeCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/safeCall.kt"); + } + + @Test + @TestMetadata("samAdapterInConstructor.kt") + public void testSamAdapterInConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/samAdapterInConstructor.kt"); + } + + @Test + @TestMetadata("samConstructor.kt") + public void testSamConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/samConstructor.kt"); + } + + @Test + @TestMetadata("starProjectionToFlexibleVariable.kt") + public void testStarProjectionToFlexibleVariable() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/starProjectionToFlexibleVariable.kt"); + } + + @Test + @TestMetadata("supertypeTypeArguments.kt") + public void testSupertypeTypeArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/supertypeTypeArguments.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/platformTypes/commonSupertype") + @TestDataPath("$PROJECT_ROOT") + public class CommonSupertype { + @Test + public void testAllFilesPresentInCommonSupertype() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/commonSupertype"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("collectionOrNull.kt") + public void testCollectionOrNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/commonSupertype/collectionOrNull.kt"); + } + + @Test + @TestMetadata("inferenceWithBound.kt") + public void testInferenceWithBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/commonSupertype/inferenceWithBound.kt"); + } + + @Test + @TestMetadata("mixedElvis.kt") + public void testMixedElvis() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/commonSupertype/mixedElvis.kt"); + } + + @Test + @TestMetadata("mixedIf.kt") + public void testMixedIf() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/commonSupertype/mixedIf.kt"); + } + + @Test + @TestMetadata("recursiveGeneric.kt") + public void testRecursiveGeneric() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/commonSupertype/recursiveGeneric.kt"); + } + + @Test + @TestMetadata("stringOrNull.kt") + public void testStringOrNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/commonSupertype/stringOrNull.kt"); + } + + @Test + @TestMetadata("typeOfElvis.kt") + public void testTypeOfElvis() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/commonSupertype/typeOfElvis.kt"); + } + + @Test + @TestMetadata("withNothing.kt") + public void testWithNothing() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/commonSupertype/withNothing.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation") + @TestDataPath("$PROJECT_ROOT") + public class GenericVarianceViolation { + @Test + public void testAllFilesPresentInGenericVarianceViolation() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("deepTypeHierarchy.kt") + public void testDeepTypeHierarchy() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/deepTypeHierarchy.kt"); + } + + @Test + @TestMetadata("inferenceFrom.kt") + public void testInferenceFrom() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/inferenceFrom.kt"); + } + + @Test + @TestMetadata("javaOutProjection.kt") + public void testJavaOutProjection() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/javaOutProjection.kt"); + } + + @Test + @TestMetadata("kotlinOutProjection.kt") + public void testKotlinOutProjection() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/kotlinOutProjection.kt"); + } + + @Test + @TestMetadata("kotlinStarProjection.kt") + public void testKotlinStarProjection() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/kotlinStarProjection.kt"); + } + + @Test + @TestMetadata("listSuperType.kt") + public void testListSuperType() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/listSuperType.kt"); + } + + @Test + @TestMetadata("rawTypes.kt") + public void testRawTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/rawTypes.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/simple.kt"); + } + + @Test + @TestMetadata("smartCast.kt") + public void testSmartCast() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/smartCast.kt"); + } + + @Test + @TestMetadata("strangeVariance.kt") + public void testStrangeVariance() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/strangeVariance.kt"); + } + + @Test + @TestMetadata("userDefinedOut.kt") + public void testUserDefinedOut() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/userDefinedOut.kt"); + } + + @Test + @TestMetadata("valueFromJava.kt") + public void testValueFromJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/valueFromJava.kt"); + } + + @Test + @TestMetadata("wildcards.kt") + public void testWildcards() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/wildcards.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/platformTypes/methodCall") + @TestDataPath("$PROJECT_ROOT") + public class MethodCall { + @Test + public void testAllFilesPresentInMethodCall() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/methodCall"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("entrySet.kt") + public void testEntrySet() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/entrySet.kt"); + } + + @Test + @TestMetadata("flexibilityThroughTypeVariable.kt") + public void testFlexibilityThroughTypeVariable() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/flexibilityThroughTypeVariable.kt"); + } + + @Test + @TestMetadata("flexibilityThroughTypeVariableOut.kt") + public void testFlexibilityThroughTypeVariableOut() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/flexibilityThroughTypeVariableOut.kt"); + } + + @Test + @TestMetadata("genericsAndArrays.kt") + public void testGenericsAndArrays() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/genericsAndArrays.kt"); + } + + @Test + @TestMetadata("int.kt") + public void testInt() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/int.kt"); + } + + @Test + @TestMetadata("intArray.kt") + public void testIntArray() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/intArray.kt"); + } + + @Test + @TestMetadata("javaCollectionToKotlin.kt") + public void testJavaCollectionToKotlin() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/javaCollectionToKotlin.kt"); + } + + @Test + @TestMetadata("javaToJava.kt") + public void testJavaToJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/javaToJava.kt"); + } + + @Test + @TestMetadata("javaToKotlin.kt") + public void testJavaToKotlin() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/javaToKotlin.kt"); + } + + @Test + @TestMetadata("kotlinCollectionToJava.kt") + public void testKotlinCollectionToJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/kotlinCollectionToJava.kt"); + } + + @Test + @TestMetadata("kt27565.kt") + public void testKt27565() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/kt27565.kt"); + } + + @Test + @TestMetadata("list.kt") + public void testList() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/list.kt"); + } + + @Test + @TestMetadata("multipleExactBounds.kt") + public void testMultipleExactBounds() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/multipleExactBounds.kt"); + } + + @Test + @TestMetadata("multipleExactBoundsNullable.kt") + public void testMultipleExactBoundsNullable() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/multipleExactBoundsNullable.kt"); + } + + @Test + @TestMetadata("objectArray.kt") + public void testObjectArray() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/objectArray.kt"); + } + + @Test + @TestMetadata("overloadingForSubclass.kt") + public void testOverloadingForSubclass() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/overloadingForSubclass.kt"); + } + + @Test + @TestMetadata("sam.kt") + public void testSam() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/sam.kt"); + } + + @Test + @TestMetadata("singleton.kt") + public void testSingleton() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/singleton.kt"); + } + + @Test + @TestMetadata("string.kt") + public void testString() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/string.kt"); + } + + @Test + @TestMetadata("visitor.kt") + public void testVisitor() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/visitor.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter") + @TestDataPath("$PROJECT_ROOT") + public class NotNullTypeParameter { + @Test + public void testAllFilesPresentInNotNullTypeParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("enhancementFromAnnotation.kt") + public void testEnhancementFromAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/enhancementFromAnnotation.kt"); + } + + @Test + @TestMetadata("enhancementFromKotlin.kt") + public void testEnhancementFromKotlin() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/enhancementFromKotlin.kt"); + } + + @Test + @TestMetadata("methodTypeParameter.kt") + public void testMethodTypeParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/methodTypeParameter.kt"); + } + + @Test + @TestMetadata("noInheritanceReturnType.kt") + public void testNoInheritanceReturnType() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/noInheritanceReturnType.kt"); + } + + @Test + @TestMetadata("noInheritanceValueParameter.kt") + public void testNoInheritanceValueParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/noInheritanceValueParameter.kt"); + } + + @Test + @TestMetadata("onTypeProjection.kt") + public void testOnTypeProjection() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/onTypeProjection.kt"); + } + + @Test + @TestMetadata("substitutionInSuperType.kt") + public void testSubstitutionInSuperType() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/substitutionInSuperType.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings") + @TestDataPath("$PROJECT_ROOT") + public class NullabilityWarnings { + @Test + public void testAllFilesPresentInNullabilityWarnings() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("arithmetic.kt") + public void testArithmetic() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/arithmetic.kt"); + } + + @Test + @TestMetadata("array.kt") + public void testArray() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/array.kt"); + } + + @Test + @TestMetadata("assignToVar.kt") + public void testAssignToVar() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/assignToVar.kt"); + } + + @Test + @TestMetadata("conditions.kt") + public void testConditions() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/conditions.kt"); + } + + @Test + @TestMetadata("dataFlowInfo.kt") + public void testDataFlowInfo() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/dataFlowInfo.kt"); + } + + @Test + @TestMetadata("defaultParameters.kt") + public void testDefaultParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/defaultParameters.kt"); + } + + @Test + @TestMetadata("delegatedProperties.kt") + public void testDelegatedProperties() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegatedProperties.kt"); + } + + @Test + @TestMetadata("delegation.kt") + public void testDelegation() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegation.kt"); + } + + @Test + @TestMetadata("derefenceExtension.kt") + public void testDerefenceExtension() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/derefenceExtension.kt"); + } + + @Test + @TestMetadata("derefenceMember.kt") + public void testDerefenceMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/derefenceMember.kt"); + } + + @Test + @TestMetadata("elvis.kt") + public void testElvis() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/elvis.kt"); + } + + @Test + @TestMetadata("expectedType.kt") + public void testExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/expectedType.kt"); + } + + @Test + @TestMetadata("for.kt") + public void testFor() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/for.kt"); + } + + @Test + @TestMetadata("functionArguments.kt") + public void testFunctionArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/functionArguments.kt"); + } + + @Test + @TestMetadata("inferenceInConditionals.kt") + public void testInferenceInConditionals() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/inferenceInConditionals.kt"); + } + + @Test + @TestMetadata("invoke.kt") + public void testInvoke() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/invoke.kt"); + } + + @Test + @TestMetadata("kt6829.kt") + public void testKt6829() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/kt6829.kt"); + } + + @Test + @TestMetadata("multiDeclaration.kt") + public void testMultiDeclaration() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/multiDeclaration.kt"); + } + + @Test + @TestMetadata("noWarningOnDoubleElvis.kt") + public void testNoWarningOnDoubleElvis() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/noWarningOnDoubleElvis.kt"); + } + + @Test + @TestMetadata("notNullAfterSafeCall.kt") + public void testNotNullAfterSafeCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAfterSafeCall.kt"); + } + + @Test + @TestMetadata("notNullAssertion.kt") + public void testNotNullAssertion() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAssertion.kt"); + } + + @Test + @TestMetadata("notNullAssertionInCall.kt") + public void testNotNullAssertionInCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAssertionInCall.kt"); + } + + @Test + @TestMetadata("notNullTypeMarkedWithNullableAnnotation.kt") + public void testNotNullTypeMarkedWithNullableAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullTypeMarkedWithNullableAnnotation.kt"); + } + + @Test + @TestMetadata("passToJava.kt") + public void testPassToJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/passToJava.kt"); + } + + @Test + @TestMetadata("primitiveArray.kt") + public void testPrimitiveArray() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/primitiveArray.kt"); + } + + @Test + @TestMetadata("safeCall.kt") + public void testSafeCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/safeCall.kt"); + } + + @Test + @TestMetadata("senselessComparisonEquals.kt") + public void testSenselessComparisonEquals() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/senselessComparisonEquals.kt"); + } + + @Test + @TestMetadata("senselessComparisonIdentityEquals.kt") + public void testSenselessComparisonIdentityEquals() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/senselessComparisonIdentityEquals.kt"); + } + + @Test + @TestMetadata("throw.kt") + public void testThrow() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/throw.kt"); + } + + @Test + @TestMetadata("uselessElvisInCall.kt") + public void testUselessElvisInCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/uselessElvisInCall.kt"); + } + + @Test + @TestMetadata("uselessElvisRightIsNull.kt") + public void testUselessElvisRightIsNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/uselessElvisRightIsNull.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/platformTypes/rawTypes") + @TestDataPath("$PROJECT_ROOT") + public class RawTypes { + @Test + public void testAllFilesPresentInRawTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/rawTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("arrays.kt") + public void testArrays() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/arrays.kt"); + } + + @Test + @TestMetadata("dontSubstituteAnotherErasedRecursiveTypeArgumentAndNonRecursive.kt") + public void testDontSubstituteAnotherErasedRecursiveTypeArgumentAndNonRecursive() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/dontSubstituteAnotherErasedRecursiveTypeArgumentAndNonRecursive.kt"); + } + + @Test + @TestMetadata("dontSubstituteAnotherErasedTypeArgumentIfRecursive.kt") + public void testDontSubstituteAnotherErasedTypeArgumentIfRecursive() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/dontSubstituteAnotherErasedTypeArgumentIfRecursive.kt"); + } + + @Test + @TestMetadata("errorType.kt") + public void testErrorType() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/errorType.kt"); + } + + @Test + @TestMetadata("genericInnerClass.kt") + public void testGenericInnerClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/genericInnerClass.kt"); + } + + @Test + @TestMetadata("interClassesRecursion.kt") + public void testInterClassesRecursion() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/interClassesRecursion.kt"); + } + + @Test + @TestMetadata("interdependentTypeParameters.kt") + public void testInterdependentTypeParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/interdependentTypeParameters.kt"); + } + + @Test + @TestMetadata("interdependentTypeParametersFromKotlin.kt") + public void testInterdependentTypeParametersFromKotlin() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/interdependentTypeParametersFromKotlin.kt"); + } + + @Test + @TestMetadata("intermediateRecursion.kt") + public void testIntermediateRecursion() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/intermediateRecursion.kt"); + } + + @Test + @TestMetadata("kt47459.kt") + public void testKt47459() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/kt47459.kt"); + } + + @Test + @TestMetadata("lostRawTypeAfterElvis.kt") + public void testLostRawTypeAfterElvis() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/lostRawTypeAfterElvis.kt"); + } + + @Test + @TestMetadata("noTypeArgumentsForRawScopedMembers.kt") + public void testNoTypeArgumentsForRawScopedMembers() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/noTypeArgumentsForRawScopedMembers.kt"); + } + + @Test + @TestMetadata("nonGenericRawMember.kt") + public void testNonGenericRawMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/nonGenericRawMember.kt"); + } + + @Test + @TestMetadata("nonProjectedInnerErasure.kt") + public void testNonProjectedInnerErasure() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/nonProjectedInnerErasure.kt"); + } + + @Test + @TestMetadata("nonRawArraysInRawType.kt") + public void testNonRawArraysInRawType() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/nonRawArraysInRawType.kt"); + } + + @Test + @TestMetadata("nonTrivialErasure.kt") + public void testNonTrivialErasure() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/nonTrivialErasure.kt"); + } + + @Test + @TestMetadata("rawEnhancment.kt") + public void testRawEnhancment() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawEnhancment.kt"); + } + + @Test + @TestMetadata("rawSupertype.kt") + public void testRawSupertype() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawSupertype.kt"); + } + + @Test + @TestMetadata("rawSupertypeOverride.kt") + public void testRawSupertypeOverride() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawSupertypeOverride.kt"); + } + + @Test + @TestMetadata("rawTypeInUpperBound.kt") + public void testRawTypeInUpperBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawTypeInUpperBound.kt"); + } + + @Test + @TestMetadata("rawTypeSyntheticExtensions.kt") + public void testRawTypeSyntheticExtensions() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawTypeSyntheticExtensions.kt"); + } + + @Test + @TestMetadata("rawWithInProjection.kt") + public void testRawWithInProjection() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawWithInProjection.kt"); + } + + @Test + @TestMetadata("recursiveBound.kt") + public void testRecursiveBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/recursiveBound.kt"); + } + + @Test + @TestMetadata("samRaw.kt") + public void testSamRaw() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/samRaw.kt"); + } + + @Test + @TestMetadata("saveRawCapabilitiesAfterSubtitution.kt") + public void testSaveRawCapabilitiesAfterSubtitution() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/saveRawCapabilitiesAfterSubtitution.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/simple.kt"); + } + + @Test + @TestMetadata("smartCastToClassWithRawSupertype.kt") + public void testSmartCastToClassWithRawSupertype() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/smartCastToClassWithRawSupertype.kt"); + } + + @Test + @TestMetadata("starProjectionToRaw.kt") + public void testStarProjectionToRaw() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/starProjectionToRaw.kt"); + } + + @Test + @TestMetadata("substituteAnotherErasedTypeArgument.kt") + public void testSubstituteAnotherErasedTypeArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/substituteAnotherErasedTypeArgument.kt"); + } + + @Test + @TestMetadata("substituteOtherErasedDeepTypeArguments.kt") + public void testSubstituteOtherErasedDeepTypeArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/substituteOtherErasedDeepTypeArguments.kt"); + } + + @Test + @TestMetadata("substituteSeveralOtherErasedDependentTypeArguments.kt") + public void testSubstituteSeveralOtherErasedDependentTypeArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/substituteSeveralOtherErasedDependentTypeArguments.kt"); + } + + @Test + @TestMetadata("substituteSeveralOtherErasedTypeArguments.kt") + public void testSubstituteSeveralOtherErasedTypeArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/substituteSeveralOtherErasedTypeArguments.kt"); + } + + @Test + @TestMetadata("superTypeErasion.kt") + public void testSuperTypeErasion() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/superTypeErasion.kt"); + } + + @Test + @TestMetadata("typeEnhancement.kt") + public void testTypeEnhancement() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/typeEnhancement.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement") + @TestDataPath("$PROJECT_ROOT") + public class TypeEnhancement { + @Test + public void testAllFilesPresentInTypeEnhancement() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("buildFlexibleEnhancement.kt") + public void testBuildFlexibleEnhancement() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/buildFlexibleEnhancement.kt"); + } + + @Test + @TestMetadata("overriddenExtensions.kt") + public void testOverriddenExtensions() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/overriddenExtensions.kt"); + } + + @Test + @TestMetadata("saveAnnotationAfterSubstitution.kt") + public void testSaveAnnotationAfterSubstitution() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/saveAnnotationAfterSubstitution.kt"); + } + + @Test + @TestMetadata("supertypeDifferentParameterNullability.kt") + public void testSupertypeDifferentParameterNullability() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/supertypeDifferentParameterNullability.kt"); + } + + @Test + @TestMetadata("supertypeDifferentReturnNullability.kt") + public void testSupertypeDifferentReturnNullability() throws Exception { + runTest("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/supertypeDifferentReturnNullability.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/privateInFile") + @TestDataPath("$PROJECT_ROOT") + public class PrivateInFile { + @Test + public void testAllFilesPresentInPrivateInFile() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/privateInFile"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("kt12429.kt") + public void testKt12429() throws Exception { + runTest("compiler/testData/diagnostics/tests/privateInFile/kt12429.kt"); + } + + @Test + @TestMetadata("topLevelAnnotationCall.kt") + public void testTopLevelAnnotationCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/privateInFile/topLevelAnnotationCall.kt"); + } + + @Test + @TestMetadata("visibility.kt") + public void testVisibility() throws Exception { + runTest("compiler/testData/diagnostics/tests/privateInFile/visibility.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/properties") + @TestDataPath("$PROJECT_ROOT") + public class Properties { + @Test + @TestMetadata("abstarctPropertyInPrimaryConstructor.kt") + public void testAbstarctPropertyInPrimaryConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/properties/abstarctPropertyInPrimaryConstructor.kt"); + } + + @Test + public void testAllFilesPresentInProperties() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/properties"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("extensionPropertyMustHaveAccessorsOrBeAbstract.kt") + public void testExtensionPropertyMustHaveAccessorsOrBeAbstract() throws Exception { + runTest("compiler/testData/diagnostics/tests/properties/extensionPropertyMustHaveAccessorsOrBeAbstract.kt"); + } + + @Test + @TestMetadata("inferPropertyTypeFromGetter.kt") + public void testInferPropertyTypeFromGetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/properties/inferPropertyTypeFromGetter.kt"); + } + + @Test + @TestMetadata("kt47621.kt") + public void testKt47621() throws Exception { + runTest("compiler/testData/diagnostics/tests/properties/kt47621.kt"); + } + + @Test + @TestMetadata("kt56707.kt") + public void testKt56707() throws Exception { + runTest("compiler/testData/diagnostics/tests/properties/kt56707.kt"); + } + + @Test + @TestMetadata("lateinitOnTopLevel.kt") + public void testLateinitOnTopLevel() throws Exception { + runTest("compiler/testData/diagnostics/tests/properties/lateinitOnTopLevel.kt"); + } + + @Test + @TestMetadata("localPropertyExtensions.kt") + public void testLocalPropertyExtensions() throws Exception { + runTest("compiler/testData/diagnostics/tests/properties/localPropertyExtensions.kt"); + } + + @Test + @TestMetadata("protectedGetterWithPublicSetter.kt") + public void testProtectedGetterWithPublicSetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/properties/protectedGetterWithPublicSetter.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/properties/backingField") + @TestDataPath("$PROJECT_ROOT") + public class BackingField { + @Test + public void testAllFilesPresentInBackingField() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/properties/backingField"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("trivialExplicitBackingFIeld.kt") + public void testTrivialExplicitBackingFIeld() throws Exception { + runTest("compiler/testData/diagnostics/tests/properties/backingField/trivialExplicitBackingFIeld.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/properties/inferenceFromGetters") + @TestDataPath("$PROJECT_ROOT") + public class InferenceFromGetters { + @Test + public void testAllFilesPresentInInferenceFromGetters() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/properties/inferenceFromGetters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("blockBodyGetter.kt") + public void testBlockBodyGetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/blockBodyGetter.kt"); + } + + @Test + @TestMetadata("cantBeInferred.kt") + public void testCantBeInferred() throws Exception { + runTest("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/cantBeInferred.kt"); + } + + @Test + @TestMetadata("explicitGetterType.kt") + public void testExplicitGetterType() throws Exception { + runTest("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/explicitGetterType.kt"); + } + + @Test + @TestMetadata("members.kt") + public void testMembers() throws Exception { + runTest("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/members.kt"); + } + + @Test + @TestMetadata("nullAsNothing.kt") + public void testNullAsNothing() throws Exception { + runTest("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/nullAsNothing.kt"); + } + + @Test + @TestMetadata("objectExpression.kt") + public void testObjectExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/objectExpression.kt"); + } + + @Test + @TestMetadata("overrides.kt") + public void testOverrides() throws Exception { + runTest("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/overrides.kt"); + } + + @Test + @TestMetadata("primaryConstructorParameter.kt") + public void testPrimaryConstructorParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/primaryConstructorParameter.kt"); + } + + @Test + @TestMetadata("recursiveGetter.kt") + public void testRecursiveGetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/recursiveGetter.kt"); + } + + @Test + @TestMetadata("topLevel.kt") + public void testTopLevel() throws Exception { + runTest("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/topLevel.kt"); + } + + @Test + @TestMetadata("vars.kt") + public void testVars() throws Exception { + runTest("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/vars.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/qualifiedExpression") + @TestDataPath("$PROJECT_ROOT") + public class QualifiedExpression { + @Test + public void testAllFilesPresentInQualifiedExpression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/qualifiedExpression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("calleeExpressionAsCallExpression.kt") + public void testCalleeExpressionAsCallExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/qualifiedExpression/calleeExpressionAsCallExpression.kt"); + } + + @Test + @TestMetadata("GenericClassVsPackage.kt") + public void testGenericClassVsPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/qualifiedExpression/GenericClassVsPackage.kt"); + } + + @Test + @TestMetadata("JavaQualifier.kt") + public void testJavaQualifier() throws Exception { + runTest("compiler/testData/diagnostics/tests/qualifiedExpression/JavaQualifier.kt"); + } + + @Test + @TestMetadata("nullCalleeExpression.kt") + public void testNullCalleeExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/qualifiedExpression/nullCalleeExpression.kt"); + } + + @Test + @TestMetadata("PackageVsClass.kt") + public void testPackageVsClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/qualifiedExpression/PackageVsClass.kt"); + } + + @Test + @TestMetadata("PackageVsClass2.kt") + public void testPackageVsClass2() throws Exception { + runTest("compiler/testData/diagnostics/tests/qualifiedExpression/PackageVsClass2.kt"); + } + + @Test + @TestMetadata("PackageVsRootClass.kt") + public void testPackageVsRootClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/qualifiedExpression/PackageVsRootClass.kt"); + } + + @Test + @TestMetadata("TypeWithError.kt") + public void testTypeWithError() throws Exception { + runTest("compiler/testData/diagnostics/tests/qualifiedExpression/TypeWithError.kt"); + } + + @Test + @TestMetadata("variableVsImportedClassifier.kt") + public void testVariableVsImportedClassifier() throws Exception { + runTest("compiler/testData/diagnostics/tests/qualifiedExpression/variableVsImportedClassifier.kt"); + } + + @Test + @TestMetadata("visibleClassVsQualifiedClass.kt") + public void testVisibleClassVsQualifiedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/qualifiedExpression/visibleClassVsQualifiedClass.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/reassignment") + @TestDataPath("$PROJECT_ROOT") + public class Reassignment { + @Test + @TestMetadata("afterfor.kt") + public void testAfterfor() throws Exception { + runTest("compiler/testData/diagnostics/tests/reassignment/afterfor.kt"); + } + + @Test + public void testAllFilesPresentInReassignment() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/reassignment"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("dowhile.kt") + public void testDowhile() throws Exception { + runTest("compiler/testData/diagnostics/tests/reassignment/dowhile.kt"); + } + + @Test + @TestMetadata("else.kt") + public void testElse() throws Exception { + runTest("compiler/testData/diagnostics/tests/reassignment/else.kt"); + } + + @Test + @TestMetadata("foronly.kt") + public void testForonly() throws Exception { + runTest("compiler/testData/diagnostics/tests/reassignment/foronly.kt"); + } + + @Test + @TestMetadata("if.kt") + public void testIf() throws Exception { + runTest("compiler/testData/diagnostics/tests/reassignment/if.kt"); + } + + @Test + @TestMetadata("ifelse.kt") + public void testIfelse() throws Exception { + runTest("compiler/testData/diagnostics/tests/reassignment/ifelse.kt"); + } + + @Test + @TestMetadata("noifelse.kt") + public void testNoifelse() throws Exception { + runTest("compiler/testData/diagnostics/tests/reassignment/noifelse.kt"); + } + + @Test + @TestMetadata("when.kt") + public void testWhen() throws Exception { + runTest("compiler/testData/diagnostics/tests/reassignment/when.kt"); + } + + @Test + @TestMetadata("whiletrue.kt") + public void testWhiletrue() throws Exception { + runTest("compiler/testData/diagnostics/tests/reassignment/whiletrue.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/recovery") + @TestDataPath("$PROJECT_ROOT") + public class Recovery { + @Test + @TestMetadata("absentLeftHandSide.kt") + public void testAbsentLeftHandSide() throws Exception { + runTest("compiler/testData/diagnostics/tests/recovery/absentLeftHandSide.kt"); + } + + @Test + public void testAllFilesPresentInRecovery() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/recovery"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("emptyTypeArgs.kt") + public void testEmptyTypeArgs() throws Exception { + runTest("compiler/testData/diagnostics/tests/recovery/emptyTypeArgs.kt"); + } + + @Test + @TestMetadata("namelessInJava.kt") + public void testNamelessInJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/recovery/namelessInJava.kt"); + } + + @Test + @TestMetadata("namelessMembers.kt") + public void testNamelessMembers() throws Exception { + runTest("compiler/testData/diagnostics/tests/recovery/namelessMembers.kt"); + } + + @Test + @TestMetadata("namelessToplevelDeclarations.kt") + public void testNamelessToplevelDeclarations() throws Exception { + runTest("compiler/testData/diagnostics/tests/recovery/namelessToplevelDeclarations.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/redeclarations") + @TestDataPath("$PROJECT_ROOT") + public class Redeclarations { + @Test + public void testAllFilesPresentInRedeclarations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/redeclarations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("ClassRedeclarationInDifferentFiles.kt") + public void testClassRedeclarationInDifferentFiles() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/ClassRedeclarationInDifferentFiles.kt"); + } + + @Test + @TestMetadata("ConflictingExtensionProperties.kt") + public void testConflictingExtensionProperties() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/ConflictingExtensionProperties.kt"); + } + + @Test + @TestMetadata("DuplicateParameterNamesInFunctionType.kt") + public void testDuplicateParameterNamesInFunctionType() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/DuplicateParameterNamesInFunctionType.kt"); + } + + @Test + @TestMetadata("EnumName.kt") + public void testEnumName() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/EnumName.kt"); + } + + @Test + @TestMetadata("FunVsCtorInDifferentFiles.kt") + public void testFunVsCtorInDifferentFiles() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/FunVsCtorInDifferentFiles.kt"); + } + + @Test + @TestMetadata("interfaceTypeParameters.kt") + public void testInterfaceTypeParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/interfaceTypeParameters.kt"); + } + + @Test + @TestMetadata("kt2418.kt") + public void testKt2418() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/kt2418.kt"); + } + + @Test + @TestMetadata("kt2438.kt") + public void testKt2438() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/kt2438.kt"); + } + + @Test + @TestMetadata("kt470.kt") + public void testKt470() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/kt470.kt"); + } + + @Test + @TestMetadata("MultiFilePackageRedeclaration.kt") + public void testMultiFilePackageRedeclaration() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/MultiFilePackageRedeclaration.kt"); + } + + @Test + @TestMetadata("NoRedeclarationForClassesInDefaultObject.kt") + public void testNoRedeclarationForClassesInDefaultObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/NoRedeclarationForClassesInDefaultObject.kt"); + } + + @Test + @TestMetadata("NoRedeclarationForEnumEntriesAndDefaultObjectMembers.kt") + public void testNoRedeclarationForEnumEntriesAndDefaultObjectMembers() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/NoRedeclarationForEnumEntriesAndDefaultObjectMembers.kt"); + } + + @Test + @TestMetadata("PropertyAndFunInClass.kt") + public void testPropertyAndFunInClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/PropertyAndFunInClass.kt"); + } + + @Test + @TestMetadata("PropertyAndInnerClass.kt") + public void testPropertyAndInnerClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/PropertyAndInnerClass.kt"); + } + + @Test + @TestMetadata("RedeclarationInDefaultObject.kt") + public void testRedeclarationInDefaultObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/RedeclarationInDefaultObject.kt"); + } + + @Test + @TestMetadata("RedeclarationInMultiFile.kt") + public void testRedeclarationInMultiFile() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/RedeclarationInMultiFile.kt"); + } + + @Test + @TestMetadata("RedeclarationMainInFile.kt") + public void testRedeclarationMainInFile() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/RedeclarationMainInFile.kt"); + } + + @Test + @TestMetadata("RedeclarationMainInMultiFile.kt") + public void testRedeclarationMainInMultiFile() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/RedeclarationMainInMultiFile.kt"); + } + + @Test + @TestMetadata("RedeclarationParameterlessMain.kt") + public void testRedeclarationParameterlessMain() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/RedeclarationParameterlessMain.kt"); + } + + @Test + @TestMetadata("RedeclarationParameterlessMainInvalid.kt") + public void testRedeclarationParameterlessMainInvalid() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/RedeclarationParameterlessMainInvalid.kt"); + } + + @Test + @TestMetadata("RedeclarationParameterlessMain_before.kt") + public void testRedeclarationParameterlessMain_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/RedeclarationParameterlessMain_before.kt"); + } + + @Test + @TestMetadata("RedeclarationSuspendMainInMultiFile.kt") + public void testRedeclarationSuspendMainInMultiFile() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/RedeclarationSuspendMainInMultiFile.kt"); + } + + @Test + @TestMetadata("RedeclarationSuspendMainInMultiFile_before.kt") + public void testRedeclarationSuspendMainInMultiFile_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/RedeclarationSuspendMainInMultiFile_before.kt"); + } + + @Test + @TestMetadata("Redeclarations.kt") + public void testRedeclarations() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/Redeclarations.kt"); + } + + @Test + @TestMetadata("RedeclarationsInObjects.kt") + public void testRedeclarationsInObjects() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/RedeclarationsInObjects.kt"); + } + + @Test + @TestMetadata("RedeclaredTypeParameters.kt") + public void testRedeclaredTypeParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/RedeclaredTypeParameters.kt"); + } + + @Test + @TestMetadata("RedeclaredValsAndVars.kt") + public void testRedeclaredValsAndVars() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/RedeclaredValsAndVars.kt"); + } + + @Test + @TestMetadata("RedeclaredValueParameters.kt") + public void testRedeclaredValueParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/RedeclaredValueParameters.kt"); + } + + @Test + @TestMetadata("RedeclaringPrivateToFile.kt") + public void testRedeclaringPrivateToFile() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/RedeclaringPrivateToFile.kt"); + } + + @Test + @TestMetadata("SingletonAndFunctionSameName.kt") + public void testSingletonAndFunctionSameName() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/SingletonAndFunctionSameName.kt"); + } + + @Test + @TestMetadata("TopLevelPropertyVsClassifier.kt") + public void testTopLevelPropertyVsClassifier() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/TopLevelPropertyVsClassifier.kt"); + } + + @Test + @TestMetadata("TypeAliasCtorVsFun.kt") + public void testTypeAliasCtorVsFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/TypeAliasCtorVsFun.kt"); + } + + @Test + @TestMetadata("TypeAliasVsClass.kt") + public void testTypeAliasVsClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/TypeAliasVsClass.kt"); + } + + @Test + @TestMetadata("TypeAliasVsProperty.kt") + public void testTypeAliasVsProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/TypeAliasVsProperty.kt"); + } + + @Test + @TestMetadata("typeParameterWithTwoBounds.kt") + public void testTypeParameterWithTwoBounds() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/typeParameterWithTwoBounds.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension") + @TestDataPath("$PROJECT_ROOT") + public class ShadowedExtension { + @Test + public void testAllFilesPresentInShadowedExtension() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("extensionFunShadowedByInnerClassConstructor.kt") + public void testExtensionFunShadowedByInnerClassConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionFunShadowedByInnerClassConstructor.kt"); + } + + @Test + @TestMetadata("extensionFunShadowedByMemberFun.kt") + public void testExtensionFunShadowedByMemberFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionFunShadowedByMemberFun.kt"); + } + + @Test + @TestMetadata("extensionFunShadowedByMemberPropertyWithInvoke.kt") + public void testExtensionFunShadowedByMemberPropertyWithInvoke() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionFunShadowedByMemberPropertyWithInvoke.kt"); + } + + @Test + @TestMetadata("extensionFunShadowedBySynthesizedMemberFun.kt") + public void testExtensionFunShadowedBySynthesizedMemberFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionFunShadowedBySynthesizedMemberFun.kt"); + } + + @Test + @TestMetadata("extensionFunVsMemberExtensionFun.kt") + public void testExtensionFunVsMemberExtensionFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionFunVsMemberExtensionFun.kt"); + } + + @Test + @TestMetadata("extensionOnErrorType.kt") + public void testExtensionOnErrorType() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionOnErrorType.kt"); + } + + @Test + @TestMetadata("extensionOnNullableReceiver.kt") + public void testExtensionOnNullableReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionOnNullableReceiver.kt"); + } + + @Test + @TestMetadata("extensionPropertyShadowedByMemberProperty.kt") + public void testExtensionPropertyShadowedByMemberProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionPropertyShadowedByMemberProperty.kt"); + } + + @Test + @TestMetadata("extensionShadowedByDelegatedMember.kt") + public void testExtensionShadowedByDelegatedMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionShadowedByDelegatedMember.kt"); + } + + @Test + @TestMetadata("extensionVsNonPublicMember.kt") + public void testExtensionVsNonPublicMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionVsNonPublicMember.kt"); + } + + @Test + @TestMetadata("infixExtensionVsNonInfixMember.kt") + public void testInfixExtensionVsNonInfixMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/infixExtensionVsNonInfixMember.kt"); + } + + @Test + @TestMetadata("localExtensionShadowedByMember.kt") + public void testLocalExtensionShadowedByMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/localExtensionShadowedByMember.kt"); + } + + @Test + @TestMetadata("memberExtensionShadowedByMember.kt") + public void testMemberExtensionShadowedByMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/memberExtensionShadowedByMember.kt"); + } + + @Test + @TestMetadata("operatorExtensionVsNonOperatorMember.kt") + public void testOperatorExtensionVsNonOperatorMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/operatorExtensionVsNonOperatorMember.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/regressions") + @TestDataPath("$PROJECT_ROOT") + public class Regressions { + @Test + public void testAllFilesPresentInRegressions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/regressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("AmbiguityOnLazyTypeComputation.kt") + public void testAmbiguityOnLazyTypeComputation() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/AmbiguityOnLazyTypeComputation.kt"); + } + + @Test + @TestMetadata("AssignmentsUnderOperators.kt") + public void testAssignmentsUnderOperators() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/AssignmentsUnderOperators.kt"); + } + + @Test + @TestMetadata("CoercionToUnit.kt") + public void testCoercionToUnit() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/CoercionToUnit.kt"); + } + + @Test + @TestMetadata("correctResultSubstitutorForErrorCandidate.kt") + public void testCorrectResultSubstitutorForErrorCandidate() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/correctResultSubstitutorForErrorCandidate.kt"); + } + + @Test + @TestMetadata("delegationWithReceiver.kt") + public void testDelegationWithReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/delegationWithReceiver.kt"); + } + + @Test + @TestMetadata("DoubleDefine.kt") + public void testDoubleDefine() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/DoubleDefine.kt"); + } + + @Test + @TestMetadata("ea40964.kt") + public void testEa40964() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/ea40964.kt"); + } + + @Test + @TestMetadata("ea43298.kt") + public void testEa43298() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/ea43298.kt"); + } + + @Test + @TestMetadata("ea53340.kt") + public void testEa53340() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/ea53340.kt"); + } + + @Test + @TestMetadata("ea65509.kt") + public void testEa65509() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/ea65509.kt"); + } + + @Test + @TestMetadata("ea66984.kt") + public void testEa66984() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/ea66984.kt"); + } + + @Test + @TestMetadata("ea69735.kt") + public void testEa69735() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/ea69735.kt"); + } + + @Test + @TestMetadata("ea72837.kt") + public void testEa72837() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/ea72837.kt"); + } + + @Test + @TestMetadata("ea76264.kt") + public void testEa76264() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/ea76264.kt"); + } + + @Test + @TestMetadata("ErrorsOnIbjectExpressionsAsParameters.kt") + public void testErrorsOnIbjectExpressionsAsParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/ErrorsOnIbjectExpressionsAsParameters.kt"); + } + + @Test + @TestMetadata("intchar.kt") + public void testIntchar() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/intchar.kt"); + } + + @Test + @TestMetadata("itselfAsUpperBound.kt") + public void testItselfAsUpperBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/itselfAsUpperBound.kt"); + } + + @Test + @TestMetadata("itselfAsUpperBoundInClass.kt") + public void testItselfAsUpperBoundInClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/itselfAsUpperBoundInClass.kt"); + } + + @Test + @TestMetadata("itselfAsUpperBoundInClassNotNull.kt") + public void testItselfAsUpperBoundInClassNotNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/itselfAsUpperBoundInClassNotNull.kt"); + } + + @Test + @TestMetadata("itselfAsUpperBoundLocal.kt") + public void testItselfAsUpperBoundLocal() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/itselfAsUpperBoundLocal.kt"); + } + + @Test + @TestMetadata("itselfAsUpperBoundMember.kt") + public void testItselfAsUpperBoundMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/itselfAsUpperBoundMember.kt"); + } + + @Test + @TestMetadata("itselfAsUpperBoundNotNull.kt") + public void testItselfAsUpperBoundNotNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/itselfAsUpperBoundNotNull.kt"); + } + + @Test + @TestMetadata("Jet11.kt") + public void testJet11() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/Jet11.kt"); + } + + @Test + @TestMetadata("Jet121.kt") + public void testJet121() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/Jet121.kt"); + } + + @Test + @TestMetadata("Jet124.kt") + public void testJet124() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/Jet124.kt"); + } + + @Test + @TestMetadata("Jet169.kt") + public void testJet169() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/Jet169.kt"); + } + + @Test + @TestMetadata("Jet17.kt") + public void testJet17() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/Jet17.kt"); + } + + @Test + @TestMetadata("Jet183.kt") + public void testJet183() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/Jet183.kt"); + } + + @Test + @TestMetadata("Jet183-1.kt") + public void testJet183_1() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/Jet183-1.kt"); + } + + @Test + @TestMetadata("Jet53.kt") + public void testJet53() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/Jet53.kt"); + } + + @Test + @TestMetadata("Jet67.kt") + public void testJet67() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/Jet67.kt"); + } + + @Test + @TestMetadata("Jet68.kt") + public void testJet68() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/Jet68.kt"); + } + + @Test + @TestMetadata("Jet69.kt") + public void testJet69() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/Jet69.kt"); + } + + @Test + @TestMetadata("Jet72.kt") + public void testJet72() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/Jet72.kt"); + } + + @Test + @TestMetadata("Jet81.kt") + public void testJet81() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/Jet81.kt"); + } + + @Test + @TestMetadata("kt10243.kt") + public void testKt10243() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt10243.kt"); + } + + @Test + @TestMetadata("kt10243a.kt") + public void testKt10243a() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt10243a.kt"); + } + + @Test + @TestMetadata("kt10633.kt") + public void testKt10633() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt10633.kt"); + } + + @Test + @TestMetadata("kt10824.kt") + public void testKt10824() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt10824.kt"); + } + + @Test + @TestMetadata("kt10843.kt") + public void testKt10843() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt10843.kt"); + } + + @Test + @TestMetadata("kt11979.kt") + public void testKt11979() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt11979.kt"); + } + + @Test + @TestMetadata("kt127.kt") + public void testKt127() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt127.kt"); + } + + @Test + @TestMetadata("kt128.kt") + public void testKt128() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt128.kt"); + } + + @Test + @TestMetadata("kt12898.kt") + public void testKt12898() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt12898.kt"); + } + + @Test + @TestMetadata("kt13685.kt") + public void testKt13685() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt13685.kt"); + } + + @Test + @TestMetadata("kt13954.kt") + public void testKt13954() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt13954.kt"); + } + + @Test + @TestMetadata("kt14740.kt") + public void testKt14740() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt14740.kt"); + } + + @Test + @TestMetadata("kt1489_1728.kt") + public void testKt1489_1728() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt1489_1728.kt"); + } + + @Test + @TestMetadata("kt1550.kt") + public void testKt1550() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt1550.kt"); + } + + @Test + @TestMetadata("kt16086.kt") + public void testKt16086() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt16086.kt"); + } + + @Test + @TestMetadata("kt16086_2.kt") + public void testKt16086_2() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt16086_2.kt"); + } + + @Test + @TestMetadata("kt1639-JFrame.kt") + public void testKt1639_JFrame() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt1639-JFrame.kt"); + } + + @Test + @TestMetadata("kt1647.kt") + public void testKt1647() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt1647.kt"); + } + + @Test + @TestMetadata("kt1736.kt") + public void testKt1736() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt1736.kt"); + } + + @Test + @TestMetadata("kt174.kt") + public void testKt174() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt174.kt"); + } + + @Test + @TestMetadata("kt201.kt") + public void testKt201() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt201.kt"); + } + + @Test + @TestMetadata("kt235.kt") + public void testKt235() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt235.kt"); + } + + @Test + @TestMetadata("kt2376.kt") + public void testKt2376() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt2376.kt"); + } + + @Test + @TestMetadata("kt24488.kt") + public void testKt24488() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt24488.kt"); + } + + @Test + @TestMetadata("kt251.kt") + public void testKt251() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt251.kt"); + } + + @Test + @TestMetadata("kt258.kt") + public void testKt258() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt258.kt"); + } + + @Test + @TestMetadata("kt26.kt") + public void testKt26() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt26.kt"); + } + + @Test + @TestMetadata("kt26303.kt") + public void testKt26303() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt26303.kt"); + } + + @Test + @TestMetadata("kt26-1.kt") + public void testKt26_1() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt26-1.kt"); + } + + @Test + @TestMetadata("kt2768.kt") + public void testKt2768() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt2768.kt"); + } + + @Test + @TestMetadata("kt28001.kt") + public void testKt28001() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt28001.kt"); + } + + @Test + @TestMetadata("kt282.kt") + public void testKt282() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt282.kt"); + } + + @Test + @TestMetadata("kt287.kt") + public void testKt287() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt287.kt"); + } + + @Test + @TestMetadata("kt2956.kt") + public void testKt2956() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt2956.kt"); + } + + @Test + @TestMetadata("kt302.kt") + public void testKt302() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt302.kt"); + } + + @Test + @TestMetadata("kt30245.kt") + public void testKt30245() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt30245.kt"); + } + + @Test + @TestMetadata("kt306.kt") + public void testKt306() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt306.kt"); + } + + @Test + @TestMetadata("kt307.kt") + public void testKt307() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt307.kt"); + } + + @Test + @TestMetadata("kt312.kt") + public void testKt312() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt312.kt"); + } + + @Test + @TestMetadata("kt313.kt") + public void testKt313() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt313.kt"); + } + + @Test + @TestMetadata("kt316.kt") + public void testKt316() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt316.kt"); + } + + @Test + @TestMetadata("kt31975.kt") + public void testKt31975() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt31975.kt"); + } + + @Test + @TestMetadata("kt32205.kt") + public void testKt32205() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt32205.kt"); + } + + @Test + @TestMetadata("kt32507.kt") + public void testKt32507() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt32507.kt"); + } + + @Test + @TestMetadata("kt32792.kt") + public void testKt32792() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt32792.kt"); + } + + @Test + @TestMetadata("kt328.kt") + public void testKt328() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt328.kt"); + } + + @Test + @TestMetadata("kt32836.kt") + public void testKt32836() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt32836.kt"); + } + + @Test + @TestMetadata("kt334.kt") + public void testKt334() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt334.kt"); + } + + @Test + @TestMetadata("kt335.336.kt") + public void testKt335_336() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt335.336.kt"); + } + + @Test + @TestMetadata("kt337.kt") + public void testKt337() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt337.kt"); + } + + @Test + @TestMetadata("kt352.kt") + public void testKt352() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt352.kt"); + } + + @Test + @TestMetadata("kt353.kt") + public void testKt353() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt353.kt"); + } + + @Test + @TestMetadata("kt3535.kt") + public void testKt3535() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt3535.kt"); + } + + @Test + @TestMetadata("kt35626.kt") + public void testKt35626() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt35626.kt"); + } + + @Test + @TestMetadata("kt35626small.kt") + public void testKt35626small() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt35626small.kt"); + } + + @Test + @TestMetadata("kt35668.kt") + public void testKt35668() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt35668.kt"); + } + + @Test + @TestMetadata("kt36222.kt") + public void testKt36222() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt36222.kt"); + } + + @Test + @TestMetadata("kt3647.kt") + public void testKt3647() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt3647.kt"); + } + + @Test + @TestMetadata("kt3731.kt") + public void testKt3731() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt3731.kt"); + } + + @Test + @TestMetadata("kt3810.kt") + public void testKt3810() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt3810.kt"); + } + + @Test + @TestMetadata("kt385.109.441.kt") + public void testKt385_109_441() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt385.109.441.kt"); + } + + @Test + @TestMetadata("kt394.kt") + public void testKt394() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt394.kt"); + } + + @Test + @TestMetadata("kt398.kt") + public void testKt398() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt398.kt"); + } + + @Test + @TestMetadata("kt399.kt") + public void testKt399() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt399.kt"); + } + + @Test + @TestMetadata("kt402.kt") + public void testKt402() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt402.kt"); + } + + @Test + @TestMetadata("kt41.kt") + public void testKt41() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt41.kt"); + } + + @Test + @TestMetadata("kt411.kt") + public void testKt411() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt411.kt"); + } + + @Test + @TestMetadata("kt439.kt") + public void testKt439() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt439.kt"); + } + + @Test + @TestMetadata("kt442.kt") + public void testKt442() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt442.kt"); + } + + @Test + @TestMetadata("kt443.kt") + public void testKt443() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt443.kt"); + } + + @Test + @TestMetadata("kt455.kt") + public void testKt455() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt455.kt"); + } + + @Test + @TestMetadata("kt456.kt") + public void testKt456() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt456.kt"); + } + + @Test + @TestMetadata("kt459.kt") + public void testKt459() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt459.kt"); + } + + @Test + @TestMetadata("kt469.kt") + public void testKt469() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt469.kt"); + } + + @Test + @TestMetadata("kt4693.kt") + public void testKt4693() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt4693.kt"); + } + + @Test + @TestMetadata("kt4827.kt") + public void testKt4827() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt4827.kt"); + } + + @Test + @TestMetadata("kt498.kt") + public void testKt498() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt498.kt"); + } + + @Test + @TestMetadata("kt524.kt") + public void testKt524() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt524.kt"); + } + + @Test + @TestMetadata("kt526UnresolvedReferenceInnerStatic.kt") + public void testKt526UnresolvedReferenceInnerStatic() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt526UnresolvedReferenceInnerStatic.kt"); + } + + @Test + @TestMetadata("kt5326.kt") + public void testKt5326() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt5326.kt"); + } + + @Test + @TestMetadata("kt5362.kt") + public void testKt5362() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt5362.kt"); + } + + @Test + @TestMetadata("kt549.kt") + public void testKt549() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt549.kt"); + } + + @Test + @TestMetadata("kt557.kt") + public void testKt557() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt557.kt"); + } + + @Test + @TestMetadata("kt571.kt") + public void testKt571() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt571.kt"); + } + + @Test + @TestMetadata("kt575.kt") + public void testKt575() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt575.kt"); + } + + @Test + @TestMetadata("kt58.kt") + public void testKt58() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt58.kt"); + } + + @Test + @TestMetadata("kt580.kt") + public void testKt580() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt580.kt"); + } + + @Test + @TestMetadata("kt588.kt") + public void testKt588() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt588.kt"); + } + + @Test + @TestMetadata("kt597.kt") + public void testKt597() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt597.kt"); + } + + @Test + @TestMetadata("kt600.kt") + public void testKt600() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt600.kt"); + } + + @Test + @TestMetadata("kt604.kt") + public void testKt604() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt604.kt"); + } + + @Test + @TestMetadata("kt618.kt") + public void testKt618() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt618.kt"); + } + + @Test + @TestMetadata("kt629.kt") + public void testKt629() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt629.kt"); + } + + @Test + @TestMetadata("kt630.kt") + public void testKt630() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt630.kt"); + } + + @Test + @TestMetadata("kt6508.kt") + public void testKt6508() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt6508.kt"); + } + + @Test + @TestMetadata("kt688.kt") + public void testKt688() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt688.kt"); + } + + @Test + @TestMetadata("kt691.kt") + public void testKt691() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt691.kt"); + } + + @Test + @TestMetadata("kt701.kt") + public void testKt701() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt701.kt"); + } + + @Test + @TestMetadata("kt716.kt") + public void testKt716() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt716.kt"); + } + + @Test + @TestMetadata("kt743.kt") + public void testKt743() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt743.kt"); + } + + @Test + @TestMetadata("kt750.kt") + public void testKt750() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt750.kt"); + } + + @Test + @TestMetadata("kt762.kt") + public void testKt762() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt762.kt"); + } + + @Test + @TestMetadata("kt7804.kt") + public void testKt7804() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt7804.kt"); + } + + @Test + @TestMetadata("kt847.kt") + public void testKt847() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt847.kt"); + } + + @Test + @TestMetadata("kt860.kt") + public void testKt860() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt860.kt"); + } + + @Test + @TestMetadata("kt9384.kt") + public void testKt9384() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt9384.kt"); + } + + @Test + @TestMetadata("kt9620.kt") + public void testKt9620() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt9620.kt"); + } + + @Test + @TestMetadata("kt9633.kt") + public void testKt9633() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt9633.kt"); + } + + @Test + @TestMetadata("kt9682.kt") + public void testKt9682() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt9682.kt"); + } + + @Test + @TestMetadata("kt9808.kt") + public void testKt9808() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt9808.kt"); + } + + @Test + @TestMetadata("LocalClassReferenceChain.kt") + public void testLocalClassReferenceChain() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/LocalClassReferenceChain.kt"); + } + + @Test + @TestMetadata("noThis.kt") + public void testNoThis() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/noThis.kt"); + } + + @Test + @TestMetadata("OrphanStarProjection.kt") + public void testOrphanStarProjection() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/OrphanStarProjection.kt"); + } + + @Test + @TestMetadata("OutProjections.kt") + public void testOutProjections() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/OutProjections.kt"); + } + + @Test + @TestMetadata("OverrideResolution.kt") + public void testOverrideResolution() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/OverrideResolution.kt"); + } + + @Test + @TestMetadata("propertyWithExtensionTypeInvoke.kt") + public void testPropertyWithExtensionTypeInvoke() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/propertyWithExtensionTypeInvoke.kt"); + } + + @Test + @TestMetadata("resolveCollectionLiteralInsideLambda.kt") + public void testResolveCollectionLiteralInsideLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/resolveCollectionLiteralInsideLambda.kt"); + } + + @Test + @TestMetadata("resolveSubclassOfList.kt") + public void testResolveSubclassOfList() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/resolveSubclassOfList.kt"); + } + + @Test + @TestMetadata("SpecififcityByReceiver.kt") + public void testSpecififcityByReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/SpecififcityByReceiver.kt"); + } + + @Test + @TestMetadata("testNestedSpecialCalls.kt") + public void testTestNestedSpecialCalls() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/testNestedSpecialCalls.kt"); + } + + @Test + @TestMetadata("TypeMismatchOnUnaryOperations.kt") + public void testTypeMismatchOnUnaryOperations() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/TypeMismatchOnUnaryOperations.kt"); + } + + @Test + @TestMetadata("TypeParameterAsASupertype.kt") + public void testTypeParameterAsASupertype() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/TypeParameterAsASupertype.kt"); + } + + @Test + @TestMetadata("UnavaliableQualifiedThis.kt") + public void testUnavaliableQualifiedThis() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/UnavaliableQualifiedThis.kt"); + } + + @Test + @TestMetadata("WrongTraceInCallResolver.kt") + public void testWrongTraceInCallResolver() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/WrongTraceInCallResolver.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/regressions/kt7585") + @TestDataPath("$PROJECT_ROOT") + public class Kt7585 { + @Test + public void testAllFilesPresentInKt7585() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/regressions/kt7585"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("base.kt") + public void testBase() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt7585/base.kt"); + } + + @Test + @TestMetadata("java.kt") + public void testJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt7585/java.kt"); + } + + @Test + @TestMetadata("twoparents.kt") + public void testTwoparents() throws Exception { + runTest("compiler/testData/diagnostics/tests/regressions/kt7585/twoparents.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/resolve") + @TestDataPath("$PROJECT_ROOT") + public class Resolve { + @Test + public void testAllFilesPresentInResolve() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("ambiguityOnPropertiesWithTheSamePackageName.kt") + public void testAmbiguityOnPropertiesWithTheSamePackageName() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/ambiguityOnPropertiesWithTheSamePackageName.kt"); + } + + @Test + @TestMetadata("ambiguityWithTwoCorrespondingFunctionTypes.kt") + public void testAmbiguityWithTwoCorrespondingFunctionTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/ambiguityWithTwoCorrespondingFunctionTypes.kt"); + } + + @Test + @TestMetadata("anonymousObjectFromTopLevelMember.kt") + public void testAnonymousObjectFromTopLevelMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/anonymousObjectFromTopLevelMember.kt"); + } + + @Test + @TestMetadata("callableReferenceInCST.kt") + public void testCallableReferenceInCST() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/callableReferenceInCST.kt"); + } + + @Test + @TestMetadata("capturedTypesInLambdaParameter.kt") + public void testCapturedTypesInLambdaParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/capturedTypesInLambdaParameter.kt"); + } + + @Test + @TestMetadata("constructorVsCompanion.kt") + public void testConstructorVsCompanion() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/constructorVsCompanion.kt"); + } + + @Test + @TestMetadata("CycleInTypeArgs.kt") + public void testCycleInTypeArgs() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/CycleInTypeArgs.kt"); + } + + @Test + @TestMetadata("HiddenDeclarations.kt") + public void testHiddenDeclarations() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/HiddenDeclarations.kt"); + } + + @Test + @TestMetadata("implicitReceiverProperty.kt") + public void testImplicitReceiverProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/implicitReceiverProperty.kt"); + } + + @Test + @TestMetadata("incompleteConstructorInvocation.kt") + public void testIncompleteConstructorInvocation() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/incompleteConstructorInvocation.kt"); + } + + @Test + @TestMetadata("inferenceInLinkedLambdas.kt") + public void testInferenceInLinkedLambdas() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/inferenceInLinkedLambdas.kt"); + } + + @Test + @TestMetadata("inferenceInLinkedLambdasDependentOnExpectedType.kt") + public void testInferenceInLinkedLambdasDependentOnExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/inferenceInLinkedLambdasDependentOnExpectedType.kt"); + } + + @Test + @TestMetadata("kt28109.kt") + public void testKt28109() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/kt28109.kt"); + } + + @Test + @TestMetadata("kt36264.kt") + public void testKt36264() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/kt36264.kt"); + } + + @Test + @TestMetadata("kt49736.kt") + public void testKt49736() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/kt49736.kt"); + } + + @Test + @TestMetadata("localObject.kt") + public void testLocalObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/localObject.kt"); + } + + @Test + @TestMetadata("newLineLambda.kt") + public void testNewLineLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/newLineLambda.kt"); + } + + @Test + @TestMetadata("noStopOnReceiverUnstableSmartCast.kt") + public void testNoStopOnReceiverUnstableSmartCast() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/noStopOnReceiverUnstableSmartCast.kt"); + } + + @Test + @TestMetadata("objectLiteralAsArgument.kt") + public void testObjectLiteralAsArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/objectLiteralAsArgument.kt"); + } + + @Test + @TestMetadata("parameterAsDefaultValueInLocalFunction.kt") + public void testParameterAsDefaultValueInLocalFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/parameterAsDefaultValueInLocalFunction.kt"); + } + + @Test + @TestMetadata("propertyInCompanionOfEnum.kt") + public void testPropertyInCompanionOfEnum() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/propertyInCompanionOfEnum.kt"); + } + + @Test + @TestMetadata("resolveAnnotatedLambdaArgument.kt") + public void testResolveAnnotatedLambdaArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/resolveAnnotatedLambdaArgument.kt"); + } + + @Test + @TestMetadata("resolveToStarImportMemberInsteadOfBuiltin.kt") + public void testResolveToStarImportMemberInsteadOfBuiltin() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/resolveToStarImportMemberInsteadOfBuiltin.kt"); + } + + @Test + @TestMetadata("resolveTypeArgsForUnresolvedCall.kt") + public void testResolveTypeArgsForUnresolvedCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/resolveTypeArgsForUnresolvedCall.kt"); + } + + @Test + @TestMetadata("resolveWithFunctionLiteralWithId.kt") + public void testResolveWithFunctionLiteralWithId() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/resolveWithFunctionLiteralWithId.kt"); + } + + @Test + @TestMetadata("resolveWithFunctionLiterals.kt") + public void testResolveWithFunctionLiterals() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/resolveWithFunctionLiterals.kt"); + } + + @Test + @TestMetadata("resolveWithFunctionLiteralsOverload.kt") + public void testResolveWithFunctionLiteralsOverload() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/resolveWithFunctionLiteralsOverload.kt"); + } + + @Test + @TestMetadata("resolveWithGenerics.kt") + public void testResolveWithGenerics() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/resolveWithGenerics.kt"); + } + + @Test + @TestMetadata("resolveWithRedeclarationError.kt") + public void testResolveWithRedeclarationError() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/resolveWithRedeclarationError.kt"); + } + + @Test + @TestMetadata("resolveWithSpecifiedFunctionLiteralWithId.kt") + public void testResolveWithSpecifiedFunctionLiteralWithId() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/resolveWithSpecifiedFunctionLiteralWithId.kt"); + } + + @Test + @TestMetadata("resolveWithoutGenerics.kt") + public void testResolveWithoutGenerics() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/resolveWithoutGenerics.kt"); + } + + @Test + @TestMetadata("smartcastToMoreSpecificProperty.kt") + public void testSmartcastToMoreSpecificProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/smartcastToMoreSpecificProperty.kt"); + } + + @Test + @TestMetadata("superInvoke.kt") + public void testSuperInvoke() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/superInvoke.kt"); + } + + @Test + @TestMetadata("typeParameterInDefaultValueInLocalFunction.kt") + public void testTypeParameterInDefaultValueInLocalFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/typeParameterInDefaultValueInLocalFunction.kt"); + } + + @Test + @TestMetadata("underscoreInCatchBlock.kt") + public void testUnderscoreInCatchBlock() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/underscoreInCatchBlock.kt"); + } + + @Test + @TestMetadata("underscoreInCatchBlockWithEnabledFeature.kt") + public void testUnderscoreInCatchBlockWithEnabledFeature() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/underscoreInCatchBlockWithEnabledFeature.kt"); + } + + @Test + @TestMetadata("varInsideLambdaThatPassedToExtensionFunctionWithTypeParametersThatDefinedInsideThisLambda.kt") + public void testVarInsideLambdaThatPassedToExtensionFunctionWithTypeParametersThatDefinedInsideThisLambda() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/varInsideLambdaThatPassedToExtensionFunctionWithTypeParametersThatDefinedInsideThisLambda.kt"); + } + + @Test + @TestMetadata("wrongNumberOfTypeArguments.kt") + public void testWrongNumberOfTypeArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/wrongNumberOfTypeArguments.kt"); + } + + @Test + @TestMetadata("wrongReceiver.kt") + public void testWrongReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/wrongReceiver.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker") + @TestDataPath("$PROJECT_ROOT") + public class DslMarker { + @Test + public void testAllFilesPresentInDslMarker() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/dslMarker"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("annotatedFunctionType.kt") + public void testAnnotatedFunctionType() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/annotatedFunctionType.kt"); + } + + @Test + @TestMetadata("annotatedFunctionType_1_4.kt") + public void testAnnotatedFunctionType_1_4() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/annotatedFunctionType_1_4.kt"); + } + + @Test + @TestMetadata("annotatedTypeArgument.kt") + public void testAnnotatedTypeArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/annotatedTypeArgument.kt"); + } + + @Test + @TestMetadata("dslMarkerOnTypealias.kt") + public void testDslMarkerOnTypealias() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/dslMarkerOnTypealias.kt"); + } + + @Test + @TestMetadata("dslMarkerWithTypealiasRecursion.kt") + public void testDslMarkerWithTypealiasRecursion() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/dslMarkerWithTypealiasRecursion.kt"); + } + + @Test + @TestMetadata("inheritedMarker.kt") + public void testInheritedMarker() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/inheritedMarker.kt"); + } + + @Test + @TestMetadata("insideTopLevelExtension.kt") + public void testInsideTopLevelExtension() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/insideTopLevelExtension.kt"); + } + + @Test + @TestMetadata("insideTopLevelExtensionAnnotatedType.kt") + public void testInsideTopLevelExtensionAnnotatedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/insideTopLevelExtensionAnnotatedType.kt"); + } + + @Test + @TestMetadata("kt29948.kt") + public void testKt29948() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/kt29948.kt"); + } + + @Test + @TestMetadata("kt31360.kt") + public void testKt31360() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/kt31360.kt"); + } + + @Test + @TestMetadata("kt46969.kt") + public void testKt46969() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/kt46969.kt"); + } + + @Test + @TestMetadata("markedReceiverWithCapturedTypeArgument.kt") + public void testMarkedReceiverWithCapturedTypeArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/markedReceiverWithCapturedTypeArgument.kt"); + } + + @Test + @TestMetadata("markersIntersection.kt") + public void testMarkersIntersection() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/markersIntersection.kt"); + } + + @Test + @TestMetadata("nestedWithSameReceiver.kt") + public void testNestedWithSameReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/nestedWithSameReceiver.kt"); + } + + @Test + @TestMetadata("properties.kt") + public void testProperties() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/properties.kt"); + } + + @Test + @TestMetadata("simpleAnnotatedClasses.kt") + public void testSimpleAnnotatedClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/simpleAnnotatedClasses.kt"); + } + + @Test + @TestMetadata("simpleAnnotatedTypes.kt") + public void testSimpleAnnotatedTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/simpleAnnotatedTypes.kt"); + } + + @Test + @TestMetadata("substitutedReceiverAnnotatedClasses.kt") + public void testSubstitutedReceiverAnnotatedClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/substitutedReceiverAnnotatedClasses.kt"); + } + + @Test + @TestMetadata("substitutedReceiverAnnotatedType.kt") + public void testSubstitutedReceiverAnnotatedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/substitutedReceiverAnnotatedType.kt"); + } + + @Test + @TestMetadata("threeImplicitReceivers.kt") + public void testThreeImplicitReceivers() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/threeImplicitReceivers.kt"); + } + + @Test + @TestMetadata("threeImplicitReceivers2.kt") + public void testThreeImplicitReceivers2() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/threeImplicitReceivers2.kt"); + } + + @Test + @TestMetadata("twoImplicitReceivers.kt") + public void testTwoImplicitReceivers() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/twoImplicitReceivers.kt"); + } + + @Test + @TestMetadata("twoLanguages.kt") + public void testTwoLanguages() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/twoLanguages.kt"); + } + + @Test + @TestMetadata("typeAliasToBuiltinFunctionType.kt") + public void testTypeAliasToBuiltinFunctionType() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/typeAliasToBuiltinFunctionType.kt"); + } + + @Test + @TestMetadata("useOfExtensions.kt") + public void testUseOfExtensions() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/useOfExtensions.kt"); + } + + @Test + @TestMetadata("usingWith.kt") + public void testUsingWith() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/usingWith.kt"); + } + + @Test + @TestMetadata("usingWithThis.kt") + public void testUsingWithThis() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/usingWithThis.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/resolve/invoke") + @TestDataPath("$PROJECT_ROOT") + public class Invoke { + @Test + public void testAllFilesPresentInInvoke() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/invoke"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("extensionValueAsNonExtension.kt") + public void testExtensionValueAsNonExtension() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/extensionValueAsNonExtension.kt"); + } + + @Test + @TestMetadata("functionExpectedWhenSeveralInvokesExist.kt") + public void testFunctionExpectedWhenSeveralInvokesExist() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/functionExpectedWhenSeveralInvokesExist.kt"); + } + + @Test + @TestMetadata("implicitInvoke.kt") + public void testImplicitInvoke() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/implicitInvoke.kt"); + } + + @Test + @TestMetadata("implicitInvokeAfterSafeCall.kt") + public void testImplicitInvokeAfterSafeCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/implicitInvokeAfterSafeCall.kt"); + } + + @Test + @TestMetadata("invokeAndSmartCast.kt") + public void testInvokeAndSmartCast() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/invokeAndSmartCast.kt"); + } + + @Test + @TestMetadata("invokeAsExtension.kt") + public void testInvokeAsExtension() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/invokeAsExtension.kt"); + } + + @Test + @TestMetadata("invokeAsMember.kt") + public void testInvokeAsMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMember.kt"); + } + + @Test + @TestMetadata("invokeAsMemberExtension.kt") + public void testInvokeAsMemberExtension() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMemberExtension.kt"); + } + + @Test + @TestMetadata("invokeAsMemberExtensionToExplicitReceiver.kt") + public void testInvokeAsMemberExtensionToExplicitReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMemberExtensionToExplicitReceiver.kt"); + } + + @Test + @TestMetadata("invokeNonExtensionLambdaInContext.kt") + public void testInvokeNonExtensionLambdaInContext() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/invokeNonExtensionLambdaInContext.kt"); + } + + @Test + @TestMetadata("invokeOnVariableWithExtensionFunctionType.kt") + public void testInvokeOnVariableWithExtensionFunctionType() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.kt"); + } + + @Test + @TestMetadata("KT-4372.kt") + public void testKT_4372() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/KT-4372.kt"); + } + + @Test + @TestMetadata("kt30695.kt") + public void testKt30695() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/kt30695.kt"); + } + + @Test + @TestMetadata("kt30695_2.kt") + public void testKt30695_2() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/kt30695_2.kt"); + } + + @Test + @TestMetadata("kt3772.kt") + public void testKt3772() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/kt3772.kt"); + } + + @Test + @TestMetadata("kt3833-invokeInsideNestedClass.kt") + public void testKt3833_invokeInsideNestedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/kt3833-invokeInsideNestedClass.kt"); + } + + @Test + @TestMetadata("kt4204-completeNestedCallsForInvoke.kt") + public void testKt4204_completeNestedCallsForInvoke() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/kt4204-completeNestedCallsForInvoke.kt"); + } + + @Test + @TestMetadata("kt4321InvokeOnEnum.kt") + public void testKt4321InvokeOnEnum() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/kt4321InvokeOnEnum.kt"); + } + + @Test + @TestMetadata("kt9517.kt") + public void testKt9517() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/kt9517.kt"); + } + + @Test + @TestMetadata("kt9805.kt") + public void testKt9805() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/kt9805.kt"); + } + + @Test + @TestMetadata("reportFunctionExpectedOnSimpleUnresolved.kt") + public void testReportFunctionExpectedOnSimpleUnresolved() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/reportFunctionExpectedOnSimpleUnresolved.kt"); + } + + @Test + @TestMetadata("reportFunctionExpectedWhenOneInvokeExist.kt") + public void testReportFunctionExpectedWhenOneInvokeExist() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/reportFunctionExpectedWhenOneInvokeExist.kt"); + } + + @Test + @TestMetadata("valNamedInvoke.kt") + public void testValNamedInvoke() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/valNamedInvoke.kt"); + } + + @Test + @TestMetadata("wrongInvokeExtension.kt") + public void testWrongInvokeExtension() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/wrongInvokeExtension.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/resolve/invoke/errors") + @TestDataPath("$PROJECT_ROOT") + public class Errors { + @Test + public void testAllFilesPresentInErrors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/invoke/errors"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("ambiguityForInvoke.kt") + public void testAmbiguityForInvoke() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/errors/ambiguityForInvoke.kt"); + } + + @Test + @TestMetadata("invisibleInvoke.kt") + public void testInvisibleInvoke() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/errors/invisibleInvoke.kt"); + } + + @Test + @TestMetadata("receiverPresenceErrorForInvoke.kt") + public void testReceiverPresenceErrorForInvoke() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/errors/receiverPresenceErrorForInvoke.kt"); + } + + @Test + @TestMetadata("typeInferenceErrorForInvoke.kt") + public void testTypeInferenceErrorForInvoke() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/errors/typeInferenceErrorForInvoke.kt"); + } + + @Test + @TestMetadata("unresolvedInvoke.kt") + public void testUnresolvedInvoke() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/errors/unresolvedInvoke.kt"); + } + + @Test + @TestMetadata("unsafeCallWithInvoke.kt") + public void testUnsafeCallWithInvoke() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/errors/unsafeCallWithInvoke.kt"); + } + + @Test + @TestMetadata("wrongReceiverForInvokeOnExpression.kt") + public void testWrongReceiverForInvokeOnExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverForInvokeOnExpression.kt"); + } + + @Test + @TestMetadata("wrongReceiverTypeForInvoke.kt") + public void testWrongReceiverTypeForInvoke() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverTypeForInvoke.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/resolve/nestedCalls") + @TestDataPath("$PROJECT_ROOT") + public class NestedCalls { + @Test + public void testAllFilesPresentInNestedCalls() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/nestedCalls"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("analyzeArgsInFreeExpressionPosition.kt") + public void testAnalyzeArgsInFreeExpressionPosition() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/nestedCalls/analyzeArgsInFreeExpressionPosition.kt"); + } + + @Test + @TestMetadata("analyzeUnmappedArguments.kt") + public void testAnalyzeUnmappedArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/nestedCalls/analyzeUnmappedArguments.kt"); + } + + @Test + @TestMetadata("argumentsInParentheses.kt") + public void testArgumentsInParentheses() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/nestedCalls/argumentsInParentheses.kt"); + } + + @Test + @TestMetadata("completeTypeInferenceForNestedInNoneApplicable.kt") + public void testCompleteTypeInferenceForNestedInNoneApplicable() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/nestedCalls/completeTypeInferenceForNestedInNoneApplicable.kt"); + } + + @Test + @TestMetadata("completeUnmappedArguments.kt") + public void testCompleteUnmappedArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/nestedCalls/completeUnmappedArguments.kt"); + } + + @Test + @TestMetadata("kt5971NestedSafeCall.kt") + public void testKt5971NestedSafeCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/nestedCalls/kt5971NestedSafeCall.kt"); + } + + @Test + @TestMetadata("kt7597.kt") + public void testKt7597() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/nestedCalls/kt7597.kt"); + } + + @Test + @TestMetadata("manyInapplicableCandidatesWithLambdas.kt") + public void testManyInapplicableCandidatesWithLambdas() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/nestedCalls/manyInapplicableCandidatesWithLambdas.kt"); + } + + @Test + @TestMetadata("twoTypeParameters.kt") + public void testTwoTypeParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/nestedCalls/twoTypeParameters.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/resolve/noCandidates") + @TestDataPath("$PROJECT_ROOT") + public class NoCandidates { + @Test + public void testAllFilesPresentInNoCandidates() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/noCandidates"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("kt2787.kt") + public void testKt2787() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/noCandidates/kt2787.kt"); + } + + @Test + @TestMetadata("resolvedToClassifier.kt") + public void testResolvedToClassifier() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/noCandidates/resolvedToClassifier.kt"); + } + + @Test + @TestMetadata("resolvedToClassifierWithReceiver.kt") + public void testResolvedToClassifierWithReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/noCandidates/resolvedToClassifierWithReceiver.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/resolve/overloadConflicts") + @TestDataPath("$PROJECT_ROOT") + public class OverloadConflicts { + @Test + public void testAllFilesPresentInOverloadConflicts() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/overloadConflicts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("allLambdas.kt") + public void testAllLambdas() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/allLambdas.kt"); + } + + @Test + @TestMetadata("extensionReceiverAndVarargs.kt") + public void testExtensionReceiverAndVarargs() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/extensionReceiverAndVarargs.kt"); + } + + @Test + @TestMetadata("genericClash.kt") + public void testGenericClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/genericClash.kt"); + } + + @Test + @TestMetadata("genericWithProjection.kt") + public void testGenericWithProjection() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/genericWithProjection.kt"); + } + + @Test + @TestMetadata("kt10472.kt") + public void testKt10472() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt10472.kt"); + } + + @Test + @TestMetadata("kt10640.kt") + public void testKt10640() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt10640.kt"); + } + + @Test + @TestMetadata("kt31670.kt") + public void testKt31670() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31670.kt"); + } + + @Test + @TestMetadata("kt31758.kt") + public void testKt31758() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31758.kt"); + } + + @Test + @TestMetadata("kt37692.kt") + public void testKt37692() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt37692.kt"); + } + + @Test + @TestMetadata("kt55722.kt") + public void testKt55722() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt55722.kt"); + } + + @Test + @TestMetadata("kt55722Initial.kt") + public void testKt55722Initial() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt55722Initial.kt"); + } + + @Test + @TestMetadata("numberOfDefaults.kt") + public void testNumberOfDefaults() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/numberOfDefaults.kt"); + } + + @Test + @TestMetadata("originalExamples.kt") + public void testOriginalExamples() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/originalExamples.kt"); + } + + @Test + @TestMetadata("overloadResolutionOnNullableContravariantParameter.kt") + public void testOverloadResolutionOnNullableContravariantParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/overloadResolutionOnNullableContravariantParameter.kt"); + } + + @Test + @TestMetadata("varargWithMoreSpecificSignature.kt") + public void testVarargWithMoreSpecificSignature() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargWithMoreSpecificSignature.kt"); + } + + @Test + @TestMetadata("varargs.kt") + public void testVarargs() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargs.kt"); + } + + @Test + @TestMetadata("varargsInDifferentPositions.kt") + public void testVarargsInDifferentPositions() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargsInDifferentPositions.kt"); + } + + @Test + @TestMetadata("varargsMixed.kt") + public void testVarargsMixed() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargsMixed.kt"); + } + + @Test + @TestMetadata("varargsWithRecursiveGenerics.kt") + public void testVarargsWithRecursiveGenerics() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargsWithRecursiveGenerics.kt"); + } + + @Test + @TestMetadata("withVariance.kt") + public void testWithVariance() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/withVariance.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/resolve/priority") + @TestDataPath("$PROJECT_ROOT") + public class Priority { + @Test + public void testAllFilesPresentInPriority() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/priority"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("invokeExtensionVsOther.kt") + public void testInvokeExtensionVsOther() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/priority/invokeExtensionVsOther.kt"); + } + + @Test + @TestMetadata("invokeExtensionVsOther2.kt") + public void testInvokeExtensionVsOther2() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/priority/invokeExtensionVsOther2.kt"); + } + + @Test + @TestMetadata("kt10219.kt") + public void testKt10219() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/priority/kt10219.kt"); + } + + @Test + @TestMetadata("kt10510.kt") + public void testKt10510() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/priority/kt10510.kt"); + } + + @Test + @TestMetadata("kt9810.kt") + public void testKt9810() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/priority/kt9810.kt"); + } + + @Test + @TestMetadata("kt9965.kt") + public void testKt9965() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/priority/kt9965.kt"); + } + + @Test + @TestMetadata("localExtVsNonLocalExt.kt") + public void testLocalExtVsNonLocalExt() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/priority/localExtVsNonLocalExt.kt"); + } + + @Test + @TestMetadata("memberVsLocalExt.kt") + public void testMemberVsLocalExt() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/priority/memberVsLocalExt.kt"); + } + + @Test + @TestMetadata("memberWithHidesMemberAnnotationVsMemberWithout.kt") + public void testMemberWithHidesMemberAnnotationVsMemberWithout() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/priority/memberWithHidesMemberAnnotationVsMemberWithout.kt"); + } + + @Test + @TestMetadata("staticVsImplicitReceiverMember.kt") + public void testStaticVsImplicitReceiverMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/priority/staticVsImplicitReceiverMember.kt"); + } + + @Test + @TestMetadata("synthesizedMembersVsExtension.kt") + public void testSynthesizedMembersVsExtension() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/priority/synthesizedMembersVsExtension.kt"); + } + + @Test + @TestMetadata("syntheticPropertiesVsExtensions.kt") + public void testSyntheticPropertiesVsExtensions() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/priority/syntheticPropertiesVsExtensions.kt"); + } + + @Test + @TestMetadata("syntheticPropertiesVsMembers.kt") + public void testSyntheticPropertiesVsMembers() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/priority/syntheticPropertiesVsMembers.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/resolve/specialConstructions") + @TestDataPath("$PROJECT_ROOT") + public class SpecialConstructions { + @Test + public void testAllFilesPresentInSpecialConstructions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/specialConstructions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("constantsInIf.kt") + public void testConstantsInIf() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/specialConstructions/constantsInIf.kt"); + } + + @Test + @TestMetadata("elvisAsCall.kt") + public void testElvisAsCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/specialConstructions/elvisAsCall.kt"); + } + + @Test + @TestMetadata("exclExclAsCall.kt") + public void testExclExclAsCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/specialConstructions/exclExclAsCall.kt"); + } + + @Test + @TestMetadata("inferenceForElvis.kt") + public void testInferenceForElvis() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/specialConstructions/inferenceForElvis.kt"); + } + + @Test + @TestMetadata("multipleSuperClasses.kt") + public void testMultipleSuperClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/specialConstructions/multipleSuperClasses.kt"); + } + + @Test + @TestMetadata("reportTypeMismatchDeeplyOnBranches.kt") + public void testReportTypeMismatchDeeplyOnBranches() throws Exception { + runTest("compiler/testData/diagnostics/tests/resolve/specialConstructions/reportTypeMismatchDeeplyOnBranches.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/safeCalls") + @TestDataPath("$PROJECT_ROOT") + public class SafeCalls { + @Test + public void testAllFilesPresentInSafeCalls() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/safeCalls"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("safeCallOnFlexibleTypeAlias.kt") + public void testSafeCallOnFlexibleTypeAlias() throws Exception { + runTest("compiler/testData/diagnostics/tests/safeCalls/safeCallOnFlexibleTypeAlias.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/samConversions") + @TestDataPath("$PROJECT_ROOT") + public class SamConversions { + @Test + public void testAllFilesPresentInSamConversions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/samConversions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("arrayAsVarargAfterSamArgument.kt") + public void testArrayAsVarargAfterSamArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/samConversions/arrayAsVarargAfterSamArgument.kt"); + } + + @Test + @TestMetadata("arrayAsVarargAfterSamArgumentProhibited.kt") + public void testArrayAsVarargAfterSamArgumentProhibited() throws Exception { + runTest("compiler/testData/diagnostics/tests/samConversions/arrayAsVarargAfterSamArgumentProhibited.kt"); + } + + @Test + @TestMetadata("arrayAsVarargAfterSamArgumentWithoutSamConversionsPerArgument.kt") + public void testArrayAsVarargAfterSamArgumentWithoutSamConversionsPerArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/samConversions/arrayAsVarargAfterSamArgumentWithoutSamConversionsPerArgument.kt"); + } + + @Test + @TestMetadata("checkSamConversionsAreDisabledByDefault.kt") + public void testCheckSamConversionsAreDisabledByDefault() throws Exception { + runTest("compiler/testData/diagnostics/tests/samConversions/checkSamConversionsAreDisabledByDefault.kt"); + } + + @Test + @TestMetadata("conversionOnLambdaAsLastExpression.kt") + public void testConversionOnLambdaAsLastExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/samConversions/conversionOnLambdaAsLastExpression.kt"); + } + + @Test + @TestMetadata("DisabledForKTSimple.kt") + public void testDisabledForKTSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/samConversions/DisabledForKTSimple.kt"); + } + + @Test + @TestMetadata("GenericSubstitution.kt") + public void testGenericSubstitution() throws Exception { + runTest("compiler/testData/diagnostics/tests/samConversions/GenericSubstitution.kt"); + } + + @Test + @TestMetadata("GenericSubstitutionKT.kt") + public void testGenericSubstitutionKT() throws Exception { + runTest("compiler/testData/diagnostics/tests/samConversions/GenericSubstitutionKT.kt"); + } + + @Test + @TestMetadata("implicitReturnType.kt") + public void testImplicitReturnType() throws Exception { + runTest("compiler/testData/diagnostics/tests/samConversions/implicitReturnType.kt"); + } + + @Test + @TestMetadata("javaMemberAgainstExtension.kt") + public void testJavaMemberAgainstExtension() throws Exception { + runTest("compiler/testData/diagnostics/tests/samConversions/javaMemberAgainstExtension.kt"); + } + + @Test + @TestMetadata("kt17765.kt") + public void testKt17765() throws Exception { + runTest("compiler/testData/diagnostics/tests/samConversions/kt17765.kt"); + } + + @Test + @TestMetadata("kt50477.kt") + public void testKt50477() throws Exception { + runTest("compiler/testData/diagnostics/tests/samConversions/kt50477.kt"); + } + + @Test + @TestMetadata("OverloadPriority.kt") + public void testOverloadPriority() throws Exception { + runTest("compiler/testData/diagnostics/tests/samConversions/OverloadPriority.kt"); + } + + @Test + @TestMetadata("OverloadPriorityKT.kt") + public void testOverloadPriorityKT() throws Exception { + runTest("compiler/testData/diagnostics/tests/samConversions/OverloadPriorityKT.kt"); + } + + @Test + @TestMetadata("SAMAfterSubstitution.kt") + public void testSAMAfterSubstitution() throws Exception { + runTest("compiler/testData/diagnostics/tests/samConversions/SAMAfterSubstitution.kt"); + } + + @Test + @TestMetadata("SAMAfterSubstitutionKT.kt") + public void testSAMAfterSubstitutionKT() throws Exception { + runTest("compiler/testData/diagnostics/tests/samConversions/SAMAfterSubstitutionKT.kt"); + } + + @Test + @TestMetadata("samConversionToGeneric.kt") + public void testSamConversionToGeneric() throws Exception { + runTest("compiler/testData/diagnostics/tests/samConversions/samConversionToGeneric.kt"); + } + + @Test + @TestMetadata("samConversionWithCondition.kt") + public void testSamConversionWithCondition() throws Exception { + runTest("compiler/testData/diagnostics/tests/samConversions/samConversionWithCondition.kt"); + } + + @Test + @TestMetadata("samConversionWithConditionJava.kt") + public void testSamConversionWithConditionJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/samConversions/samConversionWithConditionJava.kt"); + } + + @Test + @TestMetadata("samConversionWithSafeCallAndInference.kt") + public void testSamConversionWithSafeCallAndInference() throws Exception { + runTest("compiler/testData/diagnostics/tests/samConversions/samConversionWithSafeCallAndInference.kt"); + } + + @Test + @TestMetadata("samConversionsWithSmartCasts.kt") + public void testSamConversionsWithSmartCasts() throws Exception { + runTest("compiler/testData/diagnostics/tests/samConversions/samConversionsWithSmartCasts.kt"); + } + + @Test + @TestMetadata("samPriorityVsGeneric.kt") + public void testSamPriorityVsGeneric() throws Exception { + runTest("compiler/testData/diagnostics/tests/samConversions/samPriorityVsGeneric.kt"); + } + + @Test + @TestMetadata("samPriorityVsGenericCompatibilityDisabled.kt") + public void testSamPriorityVsGenericCompatibilityDisabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/samConversions/samPriorityVsGenericCompatibilityDisabled.kt"); + } + + @Test + @TestMetadata("sameCandidatesFromKotlinAndJavaInOneScope.kt") + public void testSameCandidatesFromKotlinAndJavaInOneScope() throws Exception { + runTest("compiler/testData/diagnostics/tests/samConversions/sameCandidatesFromKotlinAndJavaInOneScope.kt"); + } + + @Test + @TestMetadata("SimpleCorrect.kt") + public void testSimpleCorrect() throws Exception { + runTest("compiler/testData/diagnostics/tests/samConversions/SimpleCorrect.kt"); + } + + @Test + @TestMetadata("SimpleCorrectKT.kt") + public void testSimpleCorrectKT() throws Exception { + runTest("compiler/testData/diagnostics/tests/samConversions/SimpleCorrectKT.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/scopes") + @TestDataPath("$PROJECT_ROOT") + public class Scopes { + @Test + public void testAllFilesPresentInScopes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("AmbiguityBetweenRootAndPackage.kt") + public void testAmbiguityBetweenRootAndPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/AmbiguityBetweenRootAndPackage.kt"); + } + + @Test + @TestMetadata("AmbiguousNonExtensions.kt") + public void testAmbiguousNonExtensions() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/AmbiguousNonExtensions.kt"); + } + + @Test + @TestMetadata("genericVsNested.kt") + public void testGenericVsNested() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/genericVsNested.kt"); + } + + @Test + @TestMetadata("implicitReceiverMemberVsParameter.kt") + public void testImplicitReceiverMemberVsParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/implicitReceiverMemberVsParameter.kt"); + } + + @Test + @TestMetadata("initializerScopeOfExtensionProperty.kt") + public void testInitializerScopeOfExtensionProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/initializerScopeOfExtensionProperty.kt"); + } + + @Test + @TestMetadata("invisibleSetter.kt") + public void testInvisibleSetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/invisibleSetter.kt"); + } + + @Test + @TestMetadata("kt1078.kt") + public void testKt1078() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/kt1078.kt"); + } + + @Test + @TestMetadata("kt1080.kt") + public void testKt1080() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/kt1080.kt"); + } + + @Test + @TestMetadata("kt1244.kt") + public void testKt1244() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/kt1244.kt"); + } + + @Test + @TestMetadata("kt1248.kt") + public void testKt1248() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/kt1248.kt"); + } + + @Test + @TestMetadata("kt151.kt") + public void testKt151() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/kt151.kt"); + } + + @Test + @TestMetadata("kt1579.kt") + public void testKt1579() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/kt1579.kt"); + } + + @Test + @TestMetadata("kt1579_map_entry.kt") + public void testKt1579_map_entry() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/kt1579_map_entry.kt"); + } + + @Test + @TestMetadata("kt1580.kt") + public void testKt1580() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/kt1580.kt"); + } + + @Test + @TestMetadata("kt1642.kt") + public void testKt1642() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/kt1642.kt"); + } + + @Test + @TestMetadata("kt1738.kt") + public void testKt1738() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/kt1738.kt"); + } + + @Test + @TestMetadata("kt1805.kt") + public void testKt1805() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/kt1805.kt"); + } + + @Test + @TestMetadata("kt1806.kt") + public void testKt1806() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/kt1806.kt"); + } + + @Test + @TestMetadata("kt1822.kt") + public void testKt1822() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/kt1822.kt"); + } + + @Test + @TestMetadata("kt1942.kt") + public void testKt1942() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/kt1942.kt"); + } + + @Test + @TestMetadata("kt2262.kt") + public void testKt2262() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/kt2262.kt"); + } + + @Test + @TestMetadata("kt250.617.10.kt") + public void testKt250_617_10() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/kt250.617.10.kt"); + } + + @Test + @TestMetadata("kt323.kt") + public void testKt323() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/kt323.kt"); + } + + @Test + @TestMetadata("kt37.kt") + public void testKt37() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/kt37.kt"); + } + + @Test + @TestMetadata("kt587.kt") + public void testKt587() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/kt587.kt"); + } + + @Test + @TestMetadata("kt900.kt") + public void testKt900() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/kt900.kt"); + } + + @Test + @TestMetadata("kt900-1.kt") + public void testKt900_1() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/kt900-1.kt"); + } + + @Test + @TestMetadata("kt900-2.kt") + public void testKt900_2() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/kt900-2.kt"); + } + + @Test + @TestMetadata("kt939.kt") + public void testKt939() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/kt939.kt"); + } + + @Test + @TestMetadata("kt9430.kt") + public void testKt9430() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/kt9430.kt"); + } + + @Test + @TestMetadata("NoAmbiguityBetweenRootAndPackage.kt") + public void testNoAmbiguityBetweenRootAndPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/NoAmbiguityBetweenRootAndPackage.kt"); + } + + @Test + @TestMetadata("sameClassNameResolve.kt") + public void testSameClassNameResolve() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/sameClassNameResolve.kt"); + } + + @Test + @TestMetadata("stopResolutionOnAmbiguity.kt") + public void testStopResolutionOnAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/stopResolutionOnAmbiguity.kt"); + } + + @Test + @TestMetadata("visibility.kt") + public void testVisibility() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/visibility.kt"); + } + + @Test + @TestMetadata("visibility2.kt") + public void testVisibility2() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/visibility2.kt"); + } + + @Test + @TestMetadata("visibility3.kt") + public void testVisibility3() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/visibility3.kt"); + } + + @Test + @TestMetadata("VisibilityInClassObject.kt") + public void testVisibilityInClassObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/VisibilityInClassObject.kt"); + } + + @Test + @TestMetadata("VisibilityInheritModifier.kt") + public void testVisibilityInheritModifier() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/VisibilityInheritModifier.kt"); + } + + @Test + @TestMetadata("visibleSetterFromSyntheticProperty.kt") + public void testVisibleSetterFromSyntheticProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/visibleSetterFromSyntheticProperty.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/scopes/classHeader") + @TestDataPath("$PROJECT_ROOT") + public class ClassHeader { + @Test + public void testAllFilesPresentInClassHeader() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/classHeader"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("annotationOnClass.kt") + public void testAnnotationOnClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/classHeader/annotationOnClass.kt"); + } + + @Test + @TestMetadata("annotationOnConstructors.kt") + public void testAnnotationOnConstructors() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/classHeader/annotationOnConstructors.kt"); + } + + @Test + @TestMetadata("classGenericParameters.kt") + public void testClassGenericParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/classHeader/classGenericParameters.kt"); + } + + @Test + @TestMetadata("classParents.kt") + public void testClassParents() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/classHeader/classParents.kt"); + } + + @Test + @TestMetadata("companionNestedVsOuter.kt") + public void testCompanionNestedVsOuter() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/classHeader/companionNestedVsOuter.kt"); + } + + @Test + @TestMetadata("companionObjectParents.kt") + public void testCompanionObjectParents() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/classHeader/companionObjectParents.kt"); + } + + @Test + @TestMetadata("companionObjectSuperConstructorArguments.kt") + public void testCompanionObjectSuperConstructorArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/classHeader/companionObjectSuperConstructorArguments.kt"); + } + + @Test + @TestMetadata("constructors.kt") + public void testConstructors() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/classHeader/constructors.kt"); + } + + @Test + @TestMetadata("delegation.kt") + public void testDelegation() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/classHeader/delegation.kt"); + } + + @Test + @TestMetadata("objectParents.kt") + public void testObjectParents() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/classHeader/objectParents.kt"); + } + + @Test + @TestMetadata("objectSuperConstructorArguments.kt") + public void testObjectSuperConstructorArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/classHeader/objectSuperConstructorArguments.kt"); + } + + @Test + @TestMetadata("simpleDelegation.kt") + public void testSimpleDelegation() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/classHeader/simpleDelegation.kt"); + } + + @Test + @TestMetadata("superConstructorArguments.kt") + public void testSuperConstructorArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/classHeader/superConstructorArguments.kt"); + } + + @Test + @TestMetadata("superConstructorArgumentsInSecondaryConstructor.kt") + public void testSuperConstructorArgumentsInSecondaryConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/classHeader/superConstructorArgumentsInSecondaryConstructor.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/scopes/inheritance") + @TestDataPath("$PROJECT_ROOT") + public class Inheritance { + @Test + public void testAllFilesPresentInInheritance() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/inheritance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("companionObject.kt") + public void testCompanionObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/companionObject.kt"); + } + + @Test + @TestMetadata("companionObjectAfterJava.kt") + public void testCompanionObjectAfterJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectAfterJava.kt"); + } + + @Test + @TestMetadata("companionObjectsOrder.kt") + public void testCompanionObjectsOrder() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectsOrder.kt"); + } + + @Test + @TestMetadata("innerClasses.kt") + public void testInnerClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/innerClasses.kt"); + } + + @Test + @TestMetadata("kt3856.kt") + public void testKt3856() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/kt3856.kt"); + } + + @Test + @TestMetadata("methodsPriority.kt") + public void testMethodsPriority() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/methodsPriority.kt"); + } + + @Test + @TestMetadata("nestedClassesFromInterface.kt") + public void testNestedClassesFromInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/nestedClassesFromInterface.kt"); + } + + @Test + @TestMetadata("nestedCompanionClass.kt") + public void testNestedCompanionClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClass.kt"); + } + + @Test + @TestMetadata("nestedCompanionClassVsNested.kt") + public void testNestedCompanionClassVsNested() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNested.kt"); + } + + @Test + @TestMetadata("nestedCompanionClassVsNestedJava.kt") + public void testNestedCompanionClassVsNestedJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNestedJava.kt"); + } + + @Test + @TestMetadata("nestedFromJava.kt") + public void testNestedFromJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/nestedFromJava.kt"); + } + + @Test + @TestMetadata("nestedFromJavaAfterKotlin.kt") + public void testNestedFromJavaAfterKotlin() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/nestedFromJavaAfterKotlin.kt"); + } + + @Test + @TestMetadata("nestedVsToplevelClass.kt") + public void testNestedVsToplevelClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/nestedVsToplevelClass.kt"); + } + + @Test + @TestMetadata("severalCompanions.kt") + public void testSeveralCompanions() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/severalCompanions.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics") + @TestDataPath("$PROJECT_ROOT") + public class Statics { + @Test + public void testAllFilesPresentInStatics() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/inheritance/statics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("hidePrivateByPublic.kt") + public void testHidePrivateByPublic() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/hidePrivateByPublic.kt"); + } + + @Test + @TestMetadata("jjkj.kt") + public void testJjkj() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/jjkj.kt"); + } + + @Test + @TestMetadata("kjk.kt") + public void testKjk() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/kjk.kt"); + } + + @Test + @TestMetadata("localVsStatic.kt") + public void testLocalVsStatic() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/localVsStatic.kt"); + } + + @Test + @TestMetadata("nameClash0.kt") + public void testNameClash0() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash0.kt"); + } + + @Test + @TestMetadata("nameClash1.kt") + public void testNameClash1() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash1.kt"); + } + + @Test + @TestMetadata("nameClash2.kt") + public void testNameClash2() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash2.kt"); + } + + @Test + @TestMetadata("oneInterfaceManyTimes.kt") + public void testOneInterfaceManyTimes() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/oneInterfaceManyTimes.kt"); + } + + @Test + @TestMetadata("overloadStatic.kt") + public void testOverloadStatic() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/overloadStatic.kt"); + } + + @Test + @TestMetadata("staticFunAndPropertyImport.kt") + public void testStaticFunAndPropertyImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticFunAndPropertyImport.kt"); + } + + @Test + @TestMetadata("staticFunVsImport.kt") + public void testStaticFunVsImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticFunVsImport.kt"); + } + + @Test + @TestMetadata("staticPropertyVsImport.kt") + public void testStaticPropertyVsImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticPropertyVsImport.kt"); + } + + @Test + @TestMetadata("staticVsCompanion.kt") + public void testStaticVsCompanion() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsCompanion.kt"); + } + + @Test + @TestMetadata("staticVsMember.kt") + public void testStaticVsMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsMember.kt"); + } + + @Test + @TestMetadata("staticVsOuter.kt") + public void testStaticVsOuter() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsOuter.kt"); + } + + @Test + @TestMetadata("staticsFromjava.kt") + public void testStaticsFromjava() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticsFromjava.kt"); + } + + @Test + @TestMetadata("staticsFromjavaAfterKotlin.kt") + public void testStaticsFromjavaAfterKotlin() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticsFromjavaAfterKotlin.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject") + @TestDataPath("$PROJECT_ROOT") + public class CompanionObject { + @Test + @TestMetadata("accessToStaticMembersOfParentClassJKJ_after.kt") + public void testAccessToStaticMembersOfParentClassJKJ_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClassJKJ_after.kt"); + } + + @Test + @TestMetadata("accessToStaticMembersOfParentClassJKJ_before.kt") + public void testAccessToStaticMembersOfParentClassJKJ_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClassJKJ_before.kt"); + } + + @Test + @TestMetadata("accessToStaticMembersOfParentClass_after.kt") + public void testAccessToStaticMembersOfParentClass_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClass_after.kt"); + } + + @Test + @TestMetadata("accessToStaticMembersOfParentClass_before.kt") + public void testAccessToStaticMembersOfParentClass_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClass_before.kt"); + } + + @Test + public void testAllFilesPresentInCompanionObject() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("inheritFromContainingClass_after.kt") + public void testInheritFromContainingClass_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_after.kt"); + } + + @Test + @TestMetadata("inheritFromContainingClass_before.kt") + public void testInheritFromContainingClass_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_before.kt"); + } + + @Test + @TestMetadata("inheritFromJavaAfterKotlin_after.kt") + public void testInheritFromJavaAfterKotlin_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJavaAfterKotlin_after.kt"); + } + + @Test + @TestMetadata("inheritFromJavaAfterKotlin_before.kt") + public void testInheritFromJavaAfterKotlin_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJavaAfterKotlin_before.kt"); + } + + @Test + @TestMetadata("inheritFromJava_after.kt") + public void testInheritFromJava_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJava_after.kt"); + } + + @Test + @TestMetadata("inheritFromJava_before.kt") + public void testInheritFromJava_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJava_before.kt"); + } + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/scopes/protectedVisibility") + @TestDataPath("$PROJECT_ROOT") + public class ProtectedVisibility { + @Test + public void testAllFilesPresentInProtectedVisibility() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/protectedVisibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("complexCompanion.kt") + public void testComplexCompanion() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/complexCompanion.kt"); + } + + @Test + @TestMetadata("constructors.kt") + public void testConstructors() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/constructors.kt"); + } + + @Test + @TestMetadata("constructorsInner.kt") + public void testConstructorsInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/constructorsInner.kt"); + } + + @Test + @TestMetadata("generic.kt") + public void testGeneric() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/generic.kt"); + } + + @Test + @TestMetadata("innerClassInJava.kt") + public void testInnerClassInJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/innerClassInJava.kt"); + } + + @Test + @TestMetadata("innerProtectedClass.kt") + public void testInnerProtectedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/innerProtectedClass.kt"); + } + + @Test + @TestMetadata("javaInheritedInKotlin.kt") + public void testJavaInheritedInKotlin() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/javaInheritedInKotlin.kt"); + } + + @Test + @TestMetadata("kt7971.kt") + public void testKt7971() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/kt7971.kt"); + } + + @Test + @TestMetadata("nonSuperCallConstructor.kt") + public void testNonSuperCallConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructor.kt"); + } + + @Test + @TestMetadata("nonSuperCallConstructorJavaDifferentPackage.kt") + public void testNonSuperCallConstructorJavaDifferentPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructorJavaDifferentPackage.kt"); + } + + @Test + @TestMetadata("nonSuperCallConstructorJavaSamePackage.kt") + public void testNonSuperCallConstructorJavaSamePackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructorJavaSamePackage.kt"); + } + + @Test + @TestMetadata("protectedCallOnSubClass.kt") + public void testProtectedCallOnSubClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/protectedCallOnSubClass.kt"); + } + + @Test + @TestMetadata("protectedPropertyInPrimaryConstructor.kt") + public void testProtectedPropertyInPrimaryConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/protectedPropertyInPrimaryConstructor.kt"); + } + + @Test + @TestMetadata("smartcastOnExtensionReceiver.kt") + public void testSmartcastOnExtensionReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/smartcastOnExtensionReceiver.kt"); + } + + @Test + @TestMetadata("syntheticPropertyExtensions.kt") + public void testSyntheticPropertyExtensions() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/syntheticPropertyExtensions.kt"); + } + + @Test + @TestMetadata("syntheticSAMExtensions.kt") + public void testSyntheticSAMExtensions() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/syntheticSAMExtensions.kt"); + } + + @Test + @TestMetadata("unstableSmartCast.kt") + public void testUnstableSmartCast() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/unstableSmartCast.kt"); + } + + @Test + @TestMetadata("withSmartcast.kt") + public void testWithSmartcast() throws Exception { + runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/withSmartcast.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/script") + @TestDataPath("$PROJECT_ROOT") + public class Script { + @Test + public void testAllFilesPresentInScript() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/script"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/sealed") + @TestDataPath("$PROJECT_ROOT") + public class Sealed { + @Test + public void testAllFilesPresentInSealed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sealed"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("DerivedTopLevel.kt") + public void testDerivedTopLevel() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/DerivedTopLevel.kt"); + } + + @Test + @TestMetadata("DoubleInner.kt") + public void testDoubleInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/DoubleInner.kt"); + } + + @Test + @TestMetadata("ExhaustiveOnRoot.kt") + public void testExhaustiveOnRoot() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/ExhaustiveOnRoot.kt"); + } + + @Test + @TestMetadata("ExhaustiveOnTree.kt") + public void testExhaustiveOnTree() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/ExhaustiveOnTree.kt"); + } + + @Test + @TestMetadata("ExhaustiveOnTriangleStar.kt") + public void testExhaustiveOnTriangleStar() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/ExhaustiveOnTriangleStar.kt"); + } + + @Test + @TestMetadata("ExhaustiveWhen.kt") + public void testExhaustiveWhen() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhen.kt"); + } + + @Test + @TestMetadata("ExhaustiveWhenDoubleInner.kt") + public void testExhaustiveWhenDoubleInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenDoubleInner.kt"); + } + + @Test + @TestMetadata("ExhaustiveWhenMultipleInner.kt") + public void testExhaustiveWhenMultipleInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenMultipleInner.kt"); + } + + @Test + @TestMetadata("ExhaustiveWhenNegated.kt") + public void testExhaustiveWhenNegated() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenNegated.kt"); + } + + @Test + @TestMetadata("ExhaustiveWhenNegatedTwice.kt") + public void testExhaustiveWhenNegatedTwice() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenNegatedTwice.kt"); + } + + @Test + @TestMetadata("ExhaustiveWhenOnNestedSealed.kt") + public void testExhaustiveWhenOnNestedSealed() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenOnNestedSealed.kt"); + } + + @Test + @TestMetadata("ExhaustiveWhenOnNullable.kt") + public void testExhaustiveWhenOnNullable() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenOnNullable.kt"); + } + + @Test + @TestMetadata("ExhaustiveWhenWithAdditionalMember.kt") + public void testExhaustiveWhenWithAdditionalMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenWithAdditionalMember.kt"); + } + + @Test + @TestMetadata("ExhaustiveWhenWithElse.kt") + public void testExhaustiveWhenWithElse() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenWithElse.kt"); + } + + @Test + @TestMetadata("ExhaustiveWithFreedom.kt") + public void testExhaustiveWithFreedom() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/ExhaustiveWithFreedom.kt"); + } + + @Test + @TestMetadata("inheritorInDifferentModule.kt") + public void testInheritorInDifferentModule() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/inheritorInDifferentModule.kt"); + } + + @Test + @TestMetadata("internalTypeInConstructor.kt") + public void testInternalTypeInConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/internalTypeInConstructor.kt"); + } + + @Test + @TestMetadata("kt44316.kt") + public void testKt44316() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/kt44316.kt"); + } + + @Test + @TestMetadata("kt44861.kt") + public void testKt44861() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/kt44861.kt"); + } + + @Test + @TestMetadata("Local.kt") + public void testLocal() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/Local.kt"); + } + + @Test + @TestMetadata("LocalSealed.kt") + public void testLocalSealed() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/LocalSealed.kt"); + } + + @Test + @TestMetadata("MultipleFiles_enabled.kt") + public void testMultipleFiles_enabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/MultipleFiles_enabled.kt"); + } + + @Test + @TestMetadata("NestedSealed.kt") + public void testNestedSealed() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/NestedSealed.kt"); + } + + @Test + @TestMetadata("NestedSealedWithoutRestrictions.kt") + public void testNestedSealedWithoutRestrictions() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/NestedSealedWithoutRestrictions.kt"); + } + + @Test + @TestMetadata("NeverConstructed.kt") + public void testNeverConstructed() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/NeverConstructed.kt"); + } + + @Test + @TestMetadata("NeverDerivedFromNested.kt") + public void testNeverDerivedFromNested() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/NeverDerivedFromNested.kt"); + } + + @Test + @TestMetadata("NeverEnum.kt") + public void testNeverEnum() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/NeverEnum.kt"); + } + + @Test + @TestMetadata("NeverFinal.kt") + public void testNeverFinal() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/NeverFinal.kt"); + } + + @Test + @TestMetadata("NeverObject.kt") + public void testNeverObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/NeverObject.kt"); + } + + @Test + @TestMetadata("NeverOpen.kt") + public void testNeverOpen() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/NeverOpen.kt"); + } + + @Test + @TestMetadata("NonExhaustiveWhen.kt") + public void testNonExhaustiveWhen() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/NonExhaustiveWhen.kt"); + } + + @Test + @TestMetadata("NonExhaustiveWhenNegated.kt") + public void testNonExhaustiveWhenNegated() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/NonExhaustiveWhenNegated.kt"); + } + + @Test + @TestMetadata("NonExhaustiveWhenWithAdditionalCase.kt") + public void testNonExhaustiveWhenWithAdditionalCase() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/NonExhaustiveWhenWithAdditionalCase.kt"); + } + + @Test + @TestMetadata("NonExhaustiveWhenWithAnyCase.kt") + public void testNonExhaustiveWhenWithAnyCase() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/NonExhaustiveWhenWithAnyCase.kt"); + } + + @Test + @TestMetadata("NonPrivateConstructor.kt") + public void testNonPrivateConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/NonPrivateConstructor.kt"); + } + + @Test + @TestMetadata("NotFinal.kt") + public void testNotFinal() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/NotFinal.kt"); + } + + @Test + @TestMetadata("OperationWhen.kt") + public void testOperationWhen() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/OperationWhen.kt"); + } + + @Test + @TestMetadata("privateSealedConstructors_error.kt") + public void testPrivateSealedConstructors_error() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/privateSealedConstructors_error.kt"); + } + + @Test + @TestMetadata("privateSealedConstructors_warning.kt") + public void testPrivateSealedConstructors_warning() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/privateSealedConstructors_warning.kt"); + } + + @Test + @TestMetadata("privateTypeInConstructor.kt") + public void testPrivateTypeInConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/privateTypeInConstructor.kt"); + } + + @Test + @TestMetadata("protectedConstructors_disabled.kt") + public void testProtectedConstructors_disabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/protectedConstructors_disabled.kt"); + } + + @Test + @TestMetadata("protectedConstructors_enabled.kt") + public void testProtectedConstructors_enabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/protectedConstructors_enabled.kt"); + } + + @Test + @TestMetadata("RedundantAbstract.kt") + public void testRedundantAbstract() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/RedundantAbstract.kt"); + } + + @Test + @TestMetadata("sealedInheritorErrorMessage.kt") + public void testSealedInheritorErrorMessage() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/sealedInheritorErrorMessage.kt"); + } + + @Test + @TestMetadata("TreeWhen.kt") + public void testTreeWhen() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/TreeWhen.kt"); + } + + @Test + @TestMetadata("TreeWhenFunctional.kt") + public void testTreeWhenFunctional() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/TreeWhenFunctional.kt"); + } + + @Test + @TestMetadata("TreeWhenFunctionalNoIs.kt") + public void testTreeWhenFunctionalNoIs() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/TreeWhenFunctionalNoIs.kt"); + } + + @Test + @TestMetadata("WhenOnEmptySealed.kt") + public void testWhenOnEmptySealed() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/WhenOnEmptySealed.kt"); + } + + @Test + @TestMetadata("WithInterface.kt") + public void testWithInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/WithInterface.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/sealed/interfaces") + @TestDataPath("$PROJECT_ROOT") + public class Interfaces { + @Test + public void testAllFilesPresentInInterfaces() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sealed/interfaces"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("inheritorInDifferentModule.kt") + public void testInheritorInDifferentModule() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/interfaces/inheritorInDifferentModule.kt"); + } + + @Test + @TestMetadata("sealedFunInterface.kt") + public void testSealedFunInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/interfaces/sealedFunInterface.kt"); + } + + @Test + @TestMetadata("sealedInterfacesDisabled.kt") + public void testSealedInterfacesDisabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/interfaces/sealedInterfacesDisabled.kt"); + } + + @Test + @TestMetadata("simpleSealedInterface.kt") + public void testSimpleSealedInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/sealed/interfaces/simpleSealedInterface.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/secondaryConstructors") + @TestDataPath("$PROJECT_ROOT") + public class SecondaryConstructors { + @Test + public void testAllFilesPresentInSecondaryConstructors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("argumentsResolveInBodyAndDelegationCall.kt") + public void testArgumentsResolveInBodyAndDelegationCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/argumentsResolveInBodyAndDelegationCall.kt"); + } + + @Test + @TestMetadata("classInitializersWithoutPrimary.kt") + public void testClassInitializersWithoutPrimary() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/classInitializersWithoutPrimary.kt"); + } + + @Test + @TestMetadata("companionObjectScope.kt") + public void testCompanionObjectScope() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/companionObjectScope.kt"); + } + + @Test + @TestMetadata("constructorCallType.kt") + public void testConstructorCallType() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/constructorCallType.kt"); + } + + @Test + @TestMetadata("constructorInObject.kt") + public void testConstructorInObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/constructorInObject.kt"); + } + + @Test + @TestMetadata("constructorInTrait.kt") + public void testConstructorInTrait() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/constructorInTrait.kt"); + } + + @Test + @TestMetadata("ctrsAnnotationResolve.kt") + public void testCtrsAnnotationResolve() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/ctrsAnnotationResolve.kt"); + } + + @Test + @TestMetadata("cyclicDelegationCalls.kt") + public void testCyclicDelegationCalls() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/cyclicDelegationCalls.kt"); + } + + @Test + @TestMetadata("dataClasses.kt") + public void testDataClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/dataClasses.kt"); + } + + @Test + @TestMetadata("dataFlowInDelegationCall.kt") + public void testDataFlowInDelegationCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/dataFlowInDelegationCall.kt"); + } + + @Test + @TestMetadata("delegationByWithoutPrimary.kt") + public void testDelegationByWithoutPrimary() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/delegationByWithoutPrimary.kt"); + } + + @Test + @TestMetadata("enums.kt") + public void testEnums() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/enums.kt"); + } + + @Test + @TestMetadata("errorsOnEmptyDelegationCall.kt") + public void testErrorsOnEmptyDelegationCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/errorsOnEmptyDelegationCall.kt"); + } + + @Test + @TestMetadata("expectedPrimaryConstructorCall.kt") + public void testExpectedPrimaryConstructorCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/expectedPrimaryConstructorCall.kt"); + } + + @Test + @TestMetadata("generics.kt") + public void testGenerics() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/generics.kt"); + } + + @Test + @TestMetadata("generics2.kt") + public void testGenerics2() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/generics2.kt"); + } + + @Test + @TestMetadata("generics3.kt") + public void testGenerics3() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/generics3.kt"); + } + + @Test + @TestMetadata("headerSupertypeInitialization.kt") + public void testHeaderSupertypeInitialization() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerSupertypeInitialization.kt"); + } + + @Test + @TestMetadata("implicitSuperCallErrorsIfPrimary.kt") + public void testImplicitSuperCallErrorsIfPrimary() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/implicitSuperCallErrorsIfPrimary.kt"); + } + + @Test + @TestMetadata("initializationFromOtherInstance.kt") + public void testInitializationFromOtherInstance() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/initializationFromOtherInstance.kt"); + } + + @Test + @TestMetadata("kt6992.kt") + public void testKt6992() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/kt6992.kt"); + } + + @Test + @TestMetadata("kt6993.kt") + public void testKt6993() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/kt6993.kt"); + } + + @Test + @TestMetadata("kt6994.kt") + public void testKt6994() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/kt6994.kt"); + } + + @Test + @TestMetadata("lambdaInDelegation.kt") + public void testLambdaInDelegation() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/lambdaInDelegation.kt"); + } + + @Test + @TestMetadata("nestedExtendsInner.kt") + public void testNestedExtendsInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/nestedExtendsInner.kt"); + } + + @Test + @TestMetadata("noDefaultIfEmptySecondary.kt") + public void testNoDefaultIfEmptySecondary() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/noDefaultIfEmptySecondary.kt"); + } + + @Test + @TestMetadata("noPrimaryConstructor.kt") + public void testNoPrimaryConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/noPrimaryConstructor.kt"); + } + + @Test + @TestMetadata("noSupertypeInitWithSecondaryConstructors.kt") + public void testNoSupertypeInitWithSecondaryConstructors() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/noSupertypeInitWithSecondaryConstructors.kt"); + } + + @Test + @TestMetadata("propertyInitializationWithPrimary.kt") + public void testPropertyInitializationWithPrimary() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/propertyInitializationWithPrimary.kt"); + } + + @Test + @TestMetadata("propertyInitializationWithoutPrimary.kt") + public void testPropertyInitializationWithoutPrimary() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/propertyInitializationWithoutPrimary.kt"); + } + + @Test + @TestMetadata("redeclarations.kt") + public void testRedeclarations() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/redeclarations.kt"); + } + + @Test + @TestMetadata("redeclarationsOfConstructorsIgnored.kt") + public void testRedeclarationsOfConstructorsIgnored() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/redeclarationsOfConstructorsIgnored.kt"); + } + + @Test + @TestMetadata("reportResolutionErrorOnImplicitOnce.kt") + public void testReportResolutionErrorOnImplicitOnce() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/reportResolutionErrorOnImplicitOnce.kt"); + } + + @Test + @TestMetadata("resolvePropertyInitializerWithoutPrimary.kt") + public void testResolvePropertyInitializerWithoutPrimary() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/resolvePropertyInitializerWithoutPrimary.kt"); + } + + @Test + @TestMetadata("return.kt") + public void testReturn() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/return.kt"); + } + + @Test + @TestMetadata("superAnyNonEmpty.kt") + public void testSuperAnyNonEmpty() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/superAnyNonEmpty.kt"); + } + + @Test + @TestMetadata("superSecondaryNonExisting.kt") + public void testSuperSecondaryNonExisting() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/superSecondaryNonExisting.kt"); + } + + @Test + @TestMetadata("thisNonExisting.kt") + public void testThisNonExisting() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/thisNonExisting.kt"); + } + + @Test + @TestMetadata("unreachableCode.kt") + public void testUnreachableCode() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/unreachableCode.kt"); + } + + @Test + @TestMetadata("useOfPropertiesWithPrimary.kt") + public void testUseOfPropertiesWithPrimary() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/useOfPropertiesWithPrimary.kt"); + } + + @Test + @TestMetadata("useOfPropertiesWithoutPrimary.kt") + public void testUseOfPropertiesWithoutPrimary() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/useOfPropertiesWithoutPrimary.kt"); + } + + @Test + @TestMetadata("valOrValAndModifiersInCtr.kt") + public void testValOrValAndModifiersInCtr() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/valOrValAndModifiersInCtr.kt"); + } + + @Test + @TestMetadata("varargsInDelegationCallToPrimary.kt") + public void testVarargsInDelegationCallToPrimary() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/varargsInDelegationCallToPrimary.kt"); + } + + @Test + @TestMetadata("varargsInDelegationCallToSecondary.kt") + public void testVarargsInDelegationCallToSecondary() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/varargsInDelegationCallToSecondary.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker") + @TestDataPath("$PROJECT_ROOT") + public class HeaderCallChecker { + @Test + @TestMetadata("accessBaseGenericFromInnerExtendingSameBase.kt") + public void testAccessBaseGenericFromInnerExtendingSameBase() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessBaseGenericFromInnerExtendingSameBase.kt"); + } + + @Test + @TestMetadata("accessBaseGenericFromInnerExtendingSameBase2.kt") + public void testAccessBaseGenericFromInnerExtendingSameBase2() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessBaseGenericFromInnerExtendingSameBase2.kt"); + } + + @Test + @TestMetadata("accessBaseWithSameExtension.kt") + public void testAccessBaseWithSameExtension() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessBaseWithSameExtension.kt"); + } + + @Test + @TestMetadata("accessGenericBaseWithSameExtension.kt") + public void testAccessGenericBaseWithSameExtension() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessGenericBaseWithSameExtension.kt"); + } + + @Test + public void testAllFilesPresentInHeaderCallChecker() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("innerInstanceCreation.kt") + public void testInnerInstanceCreation() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/innerInstanceCreation.kt"); + } + + @Test + @TestMetadata("lambdaAsArgument.kt") + public void testLambdaAsArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/lambdaAsArgument.kt"); + } + + @Test + @TestMetadata("memberFunAccess.kt") + public void testMemberFunAccess() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/memberFunAccess.kt"); + } + + @Test + @TestMetadata("objectLiteralAsArgument.kt") + public void testObjectLiteralAsArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/objectLiteralAsArgument.kt"); + } + + @Test + @TestMetadata("objectLiteralAsDefaultValueParameter.kt") + public void testObjectLiteralAsDefaultValueParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/objectLiteralAsDefaultValueParameter.kt"); + } + + @Test + @TestMetadata("operatorCall.kt") + public void testOperatorCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/operatorCall.kt"); + } + + @Test + @TestMetadata("passingInstance.kt") + public void testPassingInstance() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/passingInstance.kt"); + } + + @Test + @TestMetadata("propertyAccess.kt") + public void testPropertyAccess() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/propertyAccess.kt"); + } + + @Test + @TestMetadata("propertyAccessUnitialized.kt") + public void testPropertyAccessUnitialized() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/propertyAccessUnitialized.kt"); + } + + @Test + @TestMetadata("superFunAccess.kt") + public void testSuperFunAccess() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superFunAccess.kt"); + } + + @Test + @TestMetadata("superFunAccessOverriden.kt") + public void testSuperFunAccessOverriden() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superFunAccessOverriden.kt"); + } + + @Test + @TestMetadata("superPropertyAccess.kt") + public void testSuperPropertyAccess() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superPropertyAccess.kt"); + } + + @Test + @TestMetadata("thisAsExtensionReceiver.kt") + public void testThisAsExtensionReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/thisAsExtensionReceiver.kt"); + } + + @Test + @TestMetadata("usingOuterInstance.kt") + public void testUsingOuterInstance() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/usingOuterInstance.kt"); + } + + @Test + @TestMetadata("usingOuterProperty.kt") + public void testUsingOuterProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/usingOuterProperty.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/senselessComparison") + @TestDataPath("$PROJECT_ROOT") + public class SenselessComparison { + @Test + public void testAllFilesPresentInSenselessComparison() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/senselessComparison"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("noExplicitType.kt") + public void testNoExplicitType() throws Exception { + runTest("compiler/testData/diagnostics/tests/senselessComparison/noExplicitType.kt"); + } + + @Test + @TestMetadata("parenthesized.kt") + public void testParenthesized() throws Exception { + runTest("compiler/testData/diagnostics/tests/senselessComparison/parenthesized.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/shadowing") + @TestDataPath("$PROJECT_ROOT") + public class Shadowing { + @Test + public void testAllFilesPresentInShadowing() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/shadowing"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("noNameShadowingForSimpleParameters.kt") + public void testNoNameShadowingForSimpleParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/shadowing/noNameShadowingForSimpleParameters.kt"); + } + + @Test + @TestMetadata("ShadowLambdaParameter.kt") + public void testShadowLambdaParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/shadowing/ShadowLambdaParameter.kt"); + } + + @Test + @TestMetadata("ShadowMultiDeclarationWithFunParameter.kt") + public void testShadowMultiDeclarationWithFunParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/shadowing/ShadowMultiDeclarationWithFunParameter.kt"); + } + + @Test + @TestMetadata("ShadowParameterInFunctionBody.kt") + public void testShadowParameterInFunctionBody() throws Exception { + runTest("compiler/testData/diagnostics/tests/shadowing/ShadowParameterInFunctionBody.kt"); + } + + @Test + @TestMetadata("ShadowParameterInNestedBlockInFor.kt") + public void testShadowParameterInNestedBlockInFor() throws Exception { + runTest("compiler/testData/diagnostics/tests/shadowing/ShadowParameterInNestedBlockInFor.kt"); + } + + @Test + @TestMetadata("ShadowPropertyInClosure.kt") + public void testShadowPropertyInClosure() throws Exception { + runTest("compiler/testData/diagnostics/tests/shadowing/ShadowPropertyInClosure.kt"); + } + + @Test + @TestMetadata("ShadowPropertyInFor.kt") + public void testShadowPropertyInFor() throws Exception { + runTest("compiler/testData/diagnostics/tests/shadowing/ShadowPropertyInFor.kt"); + } + + @Test + @TestMetadata("ShadowPropertyInFunction.kt") + public void testShadowPropertyInFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/shadowing/ShadowPropertyInFunction.kt"); + } + + @Test + @TestMetadata("ShadowVariableInFor.kt") + public void testShadowVariableInFor() throws Exception { + runTest("compiler/testData/diagnostics/tests/shadowing/ShadowVariableInFor.kt"); + } + + @Test + @TestMetadata("ShadowVariableInNestedBlock.kt") + public void testShadowVariableInNestedBlock() throws Exception { + runTest("compiler/testData/diagnostics/tests/shadowing/ShadowVariableInNestedBlock.kt"); + } + + @Test + @TestMetadata("ShadowVariableInNestedClosure.kt") + public void testShadowVariableInNestedClosure() throws Exception { + runTest("compiler/testData/diagnostics/tests/shadowing/ShadowVariableInNestedClosure.kt"); + } + + @Test + @TestMetadata("ShadowVariableInNestedClosureParam.kt") + public void testShadowVariableInNestedClosureParam() throws Exception { + runTest("compiler/testData/diagnostics/tests/shadowing/ShadowVariableInNestedClosureParam.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/smartCasts") + @TestDataPath("$PROJECT_ROOT") + public class SmartCasts { + @Test + @TestMetadata("afterBinaryExpr.kt") + public void testAfterBinaryExpr() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/afterBinaryExpr.kt"); + } + + @Test + public void testAllFilesPresentInSmartCasts() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("alwaysNull.kt") + public void testAlwaysNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/alwaysNull.kt"); + } + + @Test + @TestMetadata("alwaysNullWithJava.kt") + public void testAlwaysNullWithJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/alwaysNullWithJava.kt"); + } + + @Test + @TestMetadata("classObjectMember.kt") + public void testClassObjectMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/classObjectMember.kt"); + } + + @Test + @TestMetadata("combineWithNoSelectorInfo.kt") + public void testCombineWithNoSelectorInfo() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/combineWithNoSelectorInfo.kt"); + } + + @Test + @TestMetadata("comparisonUnderAnd.kt") + public void testComparisonUnderAnd() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/comparisonUnderAnd.kt"); + } + + @Test + @TestMetadata("complexComparison.kt") + public void testComplexComparison() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/complexComparison.kt"); + } + + @Test + @TestMetadata("complexConditionsWithExcl.kt") + public void testComplexConditionsWithExcl() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/complexConditionsWithExcl.kt"); + } + + @Test + @TestMetadata("dataFlowInfoForArguments.kt") + public void testDataFlowInfoForArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/dataFlowInfoForArguments.kt"); + } + + @Test + @TestMetadata("doubleLambdaArgument.kt") + public void testDoubleLambdaArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/doubleLambdaArgument.kt"); + } + + @Test + @TestMetadata("elvisExclExcl.kt") + public void testElvisExclExcl() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/elvisExclExcl.kt"); + } + + @Test + @TestMetadata("elvisExclExclMerge.kt") + public void testElvisExclExclMerge() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/elvisExclExclMerge.kt"); + } + + @Test + @TestMetadata("elvisExclExclPlatform.kt") + public void testElvisExclExclPlatform() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/elvisExclExclPlatform.kt"); + } + + @Test + @TestMetadata("elvisExprNotNull.kt") + public void testElvisExprNotNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/elvisExprNotNull.kt"); + } + + @Test + @TestMetadata("elvisNothingRHS.kt") + public void testElvisNothingRHS() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/elvisNothingRHS.kt"); + } + + @Test + @TestMetadata("elvisRHS.kt") + public void testElvisRHS() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/elvisRHS.kt"); + } + + @Test + @TestMetadata("enumEntryMembers_after.kt") + public void testEnumEntryMembers_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/enumEntryMembers_after.kt"); + } + + @Test + @TestMetadata("enumEntryMembers_before.kt") + public void testEnumEntryMembers_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/enumEntryMembers_before.kt"); + } + + @Test + @TestMetadata("equals.kt") + public void testEquals() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/equals.kt"); + } + + @Test + @TestMetadata("exclUnderAnd.kt") + public void testExclUnderAnd() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/exclUnderAnd.kt"); + } + + @Test + @TestMetadata("explicitDefaultGetter.kt") + public void testExplicitDefaultGetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/explicitDefaultGetter.kt"); + } + + @Test + @TestMetadata("extensionSafeCall.kt") + public void testExtensionSafeCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/extensionSafeCall.kt"); + } + + @Test + @TestMetadata("fakeSmartCastOnEquality.kt") + public void testFakeSmartCastOnEquality() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/fakeSmartCastOnEquality.kt"); + } + + @Test + @TestMetadata("falseReceiverSmartCast.kt") + public void testFalseReceiverSmartCast() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/falseReceiverSmartCast.kt"); + } + + @Test + @TestMetadata("falseUnnecessaryCall.kt") + public void testFalseUnnecessaryCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/falseUnnecessaryCall.kt"); + } + + @Test + @TestMetadata("fieldExclExcl.kt") + public void testFieldExclExcl() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/fieldExclExcl.kt"); + } + + @Test + @TestMetadata("fieldInGetter.kt") + public void testFieldInGetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/fieldInGetter.kt"); + } + + @Test + @TestMetadata("fieldPlus.kt") + public void testFieldPlus() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/fieldPlus.kt"); + } + + @Test + @TestMetadata("genericIntersection.kt") + public void testGenericIntersection() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/genericIntersection.kt"); + } + + @Test + @TestMetadata("genericSet.kt") + public void testGenericSet() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/genericSet.kt"); + } + + @Test + @TestMetadata("ifCascadeExprNotNull.kt") + public void testIfCascadeExprNotNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/ifCascadeExprNotNull.kt"); + } + + @Test + @TestMetadata("ifExprInConditionNonNull.kt") + public void testIfExprInConditionNonNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/ifExprInConditionNonNull.kt"); + } + + @Test + @TestMetadata("ifExprInWhenSubjectNonNull.kt") + public void testIfExprInWhenSubjectNonNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/ifExprInWhenSubjectNonNull.kt"); + } + + @Test + @TestMetadata("ifExprNonNull.kt") + public void testIfExprNonNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/ifExprNonNull.kt"); + } + + @Test + @TestMetadata("ifWhenExprNonNull.kt") + public void testIfWhenExprNonNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/ifWhenExprNonNull.kt"); + } + + @Test + @TestMetadata("implicitReceiver.kt") + public void testImplicitReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/implicitReceiver.kt"); + } + + @Test + @TestMetadata("implicitReceiverAcrossFunctions.kt") + public void testImplicitReceiverAcrossFunctions() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/implicitReceiverAcrossFunctions.kt"); + } + + @Test + @TestMetadata("implicitThisOnRefInLambdaInSmartcast.kt") + public void testImplicitThisOnRefInLambdaInSmartcast() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/implicitThisOnRefInLambdaInSmartcast.kt"); + } + + @Test + @TestMetadata("implicitThisOrLocalVar.kt") + public void testImplicitThisOrLocalVar() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/implicitThisOrLocalVar.kt"); + } + + @Test + @TestMetadata("implicitToGrandSon.kt") + public void testImplicitToGrandSon() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/implicitToGrandSon.kt"); + } + + @Test + @TestMetadata("incDecToNull.kt") + public void testIncDecToNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/incDecToNull.kt"); + } + + @Test + @TestMetadata("kt10232.kt") + public void testKt10232() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/kt10232.kt"); + } + + @Test + @TestMetadata("kt10444.kt") + public void testKt10444() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/kt10444.kt"); + } + + @Test + @TestMetadata("kt10483.kt") + public void testKt10483() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/kt10483.kt"); + } + + @Test + @TestMetadata("kt1461.kt") + public void testKt1461() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/kt1461.kt"); + } + + @Test + @TestMetadata("kt2422.kt") + public void testKt2422() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/kt2422.kt"); + } + + @Test + @TestMetadata("kt27221.kt") + public void testKt27221() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/kt27221.kt"); + } + + @Test + @TestMetadata("kt27221_2.kt") + public void testKt27221_2() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/kt27221_2.kt"); + } + + @Test + @TestMetadata("kt27221_irrelevantClasses.kt") + public void testKt27221_irrelevantClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/kt27221_irrelevantClasses.kt"); + } + + @Test + @TestMetadata("kt2865.kt") + public void testKt2865() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/kt2865.kt"); + } + + @Test + @TestMetadata("kt30826.kt") + public void testKt30826() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/kt30826.kt"); + } + + @Test + @TestMetadata("kt30927.kt") + public void testKt30927() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/kt30927.kt"); + } + + @Test + @TestMetadata("kt3224.kt") + public void testKt3224() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/kt3224.kt"); + } + + @Test + @TestMetadata("kt32358_1.kt") + public void testKt32358_1() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/kt32358_1.kt"); + } + + @Test + @TestMetadata("kt32358_2.kt") + public void testKt32358_2() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/kt32358_2.kt"); + } + + @Test + @TestMetadata("kt32358_3.kt") + public void testKt32358_3() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/kt32358_3.kt"); + } + + @Test + @TestMetadata("kt3244.kt") + public void testKt3244() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/kt3244.kt"); + } + + @Test + @TestMetadata("kt3572.kt") + public void testKt3572() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/kt3572.kt"); + } + + @Test + @TestMetadata("kt3711.kt") + public void testKt3711() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/kt3711.kt"); + } + + @Test + @TestMetadata("kt3899.kt") + public void testKt3899() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/kt3899.kt"); + } + + @Test + @TestMetadata("kt3993.kt") + public void testKt3993() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/kt3993.kt"); + } + + @Test + @TestMetadata("kt45814.kt") + public void testKt45814() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/kt45814.kt"); + } + + @Test + @TestMetadata("kt51460.kt") + public void testKt51460() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/kt51460.kt"); + } + + @Test + @TestMetadata("kt5427.kt") + public void testKt5427() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/kt5427.kt"); + } + + @Test + @TestMetadata("kt5455.kt") + public void testKt5455() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/kt5455.kt"); + } + + @Test + @TestMetadata("kt6819.kt") + public void testKt6819() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/kt6819.kt"); + } + + @Test + @TestMetadata("kt7561.kt") + public void testKt7561() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/kt7561.kt"); + } + + @Test + @TestMetadata("lambdaAndArgument.kt") + public void testLambdaAndArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaAndArgument.kt"); + } + + @Test + @TestMetadata("lambdaAndArgumentFun.kt") + public void testLambdaAndArgumentFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaAndArgumentFun.kt"); + } + + @Test + @TestMetadata("lambdaArgumentNoSubstitutedReturn.kt") + public void testLambdaArgumentNoSubstitutedReturn() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentNoSubstitutedReturn.kt"); + } + + @Test + @TestMetadata("lambdaArgumentWithBoundWithoutType.kt") + public void testLambdaArgumentWithBoundWithoutType() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithBoundWithoutType.kt"); + } + + @Test + @TestMetadata("lambdaArgumentWithExpectedGenericType.kt") + public void testLambdaArgumentWithExpectedGenericType() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithExpectedGenericType.kt"); + } + + @Test + @TestMetadata("lambdaArgumentWithoutType.kt") + public void testLambdaArgumentWithoutType() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithoutType.kt"); + } + + @Test + @TestMetadata("lambdaArgumentWithoutTypeIf.kt") + public void testLambdaArgumentWithoutTypeIf() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithoutTypeIf.kt"); + } + + @Test + @TestMetadata("lambdaArgumentWithoutTypeIfMerge.kt") + public void testLambdaArgumentWithoutTypeIfMerge() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithoutTypeIfMerge.kt"); + } + + @Test + @TestMetadata("lambdaArgumentWithoutTypeWhen.kt") + public void testLambdaArgumentWithoutTypeWhen() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithoutTypeWhen.kt"); + } + + @Test + @TestMetadata("lambdaCall.kt") + public void testLambdaCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaCall.kt"); + } + + @Test + @TestMetadata("lambdaCallAnnotated.kt") + public void testLambdaCallAnnotated() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaCallAnnotated.kt"); + } + + @Test + @TestMetadata("lambdaDeclaresAndModifies.kt") + public void testLambdaDeclaresAndModifies() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaDeclaresAndModifies.kt"); + } + + @Test + @TestMetadata("lambdaDeclaresAndModifiesInLoop.kt") + public void testLambdaDeclaresAndModifiesInLoop() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaDeclaresAndModifiesInLoop.kt"); + } + + @Test + @TestMetadata("lambdaDeclaresAndModifiesInSecondary.kt") + public void testLambdaDeclaresAndModifiesInSecondary() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaDeclaresAndModifiesInSecondary.kt"); + } + + @Test + @TestMetadata("lambdaDeclaresAndModifiesWithDirectEq.kt") + public void testLambdaDeclaresAndModifiesWithDirectEq() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaDeclaresAndModifiesWithDirectEq.kt"); + } + + @Test + @TestMetadata("lambdaUsesOwnerModifies.kt") + public void testLambdaUsesOwnerModifies() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaUsesOwnerModifies.kt"); + } + + @Test + @TestMetadata("localClassChanges.kt") + public void testLocalClassChanges() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/localClassChanges.kt"); + } + + @Test + @TestMetadata("localDelegatedPropertyAfter.kt") + public void testLocalDelegatedPropertyAfter() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/localDelegatedPropertyAfter.kt"); + } + + @Test + @TestMetadata("localDelegatedPropertyBefore.kt") + public void testLocalDelegatedPropertyBefore() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/localDelegatedPropertyBefore.kt"); + } + + @Test + @TestMetadata("localFunBetween.kt") + public void testLocalFunBetween() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/localFunBetween.kt"); + } + + @Test + @TestMetadata("localFunChanges.kt") + public void testLocalFunChanges() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/localFunChanges.kt"); + } + + @Test + @TestMetadata("localObjectChanges.kt") + public void testLocalObjectChanges() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/localObjectChanges.kt"); + } + + @Test + @TestMetadata("multipleResolvedCalls.kt") + public void testMultipleResolvedCalls() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/multipleResolvedCalls.kt"); + } + + @Test + @TestMetadata("noErrorCheckForPackageLevelVal.kt") + public void testNoErrorCheckForPackageLevelVal() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/noErrorCheckForPackageLevelVal.kt"); + } + + @Test + @TestMetadata("noSmartcastForNonFinalMembersFromJava.kt") + public void testNoSmartcastForNonFinalMembersFromJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/noSmartcastForNonFinalMembersFromJava.kt"); + } + + @Test + @TestMetadata("noUnnecessarySmartCastForReceiver.kt") + public void testNoUnnecessarySmartCastForReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/noUnnecessarySmartCastForReceiver.kt"); + } + + @Test + @TestMetadata("notNullorNotNull.kt") + public void testNotNullorNotNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/notNullorNotNull.kt"); + } + + @Test + @TestMetadata("openInSealed.kt") + public void testOpenInSealed() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/openInSealed.kt"); + } + + @Test + @TestMetadata("ownerDeclaresBothModifies.kt") + public void testOwnerDeclaresBothModifies() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/ownerDeclaresBothModifies.kt"); + } + + @Test + @TestMetadata("propertyAsCondition.kt") + public void testPropertyAsCondition() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/propertyAsCondition.kt"); + } + + @Test + @TestMetadata("propertyToNotNull.kt") + public void testPropertyToNotNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/propertyToNotNull.kt"); + } + + @Test + @TestMetadata("safeAs.kt") + public void testSafeAs() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safeAs.kt"); + } + + @Test + @TestMetadata("severalSmartCastsOnReified.kt") + public void testSeveralSmartCastsOnReified() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/severalSmartCastsOnReified.kt"); + } + + @Test + @TestMetadata("shortIfExprNotNull.kt") + public void testShortIfExprNotNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/shortIfExprNotNull.kt"); + } + + @Test + @TestMetadata("smartCastAndArgumentApproximation.kt") + public void testSmartCastAndArgumentApproximation() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/smartCastAndArgumentApproximation.kt"); + } + + @Test + @TestMetadata("smartCastOnAlienPropertyFromInvisibleClass.kt") + public void testSmartCastOnAlienPropertyFromInvisibleClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/smartCastOnAlienPropertyFromInvisibleClass.kt"); + } + + @Test + @TestMetadata("smartCastOnAlienPropertyFromInvisibleClassForbidden.kt") + public void testSmartCastOnAlienPropertyFromInvisibleClassForbidden() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/smartCastOnAlienPropertyFromInvisibleClassForbidden.kt"); + } + + @Test + @TestMetadata("smartCastOnElvis.kt") + public void testSmartCastOnElvis() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/smartCastOnElvis.kt"); + } + + @Test + @TestMetadata("smartCastOnIf.kt") + public void testSmartCastOnIf() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/smartCastOnIf.kt"); + } + + @Test + @TestMetadata("smartCastOnLastExpressionOfLambdaAfterNothing.kt") + public void testSmartCastOnLastExpressionOfLambdaAfterNothing() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/smartCastOnLastExpressionOfLambdaAfterNothing.kt"); + } + + @Test + @TestMetadata("smartCastOnWhen.kt") + public void testSmartCastOnWhen() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/smartCastOnWhen.kt"); + } + + @Test + @TestMetadata("smartcastOnSameFieldOfDifferentInstances.kt") + public void testSmartcastOnSameFieldOfDifferentInstances() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/smartcastOnSameFieldOfDifferentInstances.kt"); + } + + @Test + @TestMetadata("smartcastToInvisibleType_java.kt") + public void testSmartcastToInvisibleType_java() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/smartcastToInvisibleType_java.kt"); + } + + @Test + @TestMetadata("smartcastToInvisibleType_kotlin.kt") + public void testSmartcastToInvisibleType_kotlin() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/smartcastToInvisibleType_kotlin.kt"); + } + + @Test + @TestMetadata("smartcastToNothingAfterCheckingForNull.kt") + public void testSmartcastToNothingAfterCheckingForNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/smartcastToNothingAfterCheckingForNull.kt"); + } + + @Test + @TestMetadata("smartcastToStarProjection.kt") + public void testSmartcastToStarProjection() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/smartcastToStarProjection.kt"); + } + + @Test + @TestMetadata("thisWithLabel.kt") + public void testThisWithLabel() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/thisWithLabel.kt"); + } + + @Test + @TestMetadata("thisWithLabelAsReceiverPart.kt") + public void testThisWithLabelAsReceiverPart() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/thisWithLabelAsReceiverPart.kt"); + } + + @Test + @TestMetadata("threeImplicitReceivers.kt") + public void testThreeImplicitReceivers() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/threeImplicitReceivers.kt"); + } + + @Test + @TestMetadata("throwInTry.kt") + public void testThrowInTry() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/throwInTry.kt"); + } + + @Test + @TestMetadata("toInvisible.kt") + public void testToInvisible() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/toInvisible.kt"); + } + + @Test + @TestMetadata("twoImplicitReceivers.kt") + public void testTwoImplicitReceivers() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/twoImplicitReceivers.kt"); + } + + @Test + @TestMetadata("typeDegradation.kt") + public void testTypeDegradation() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/typeDegradation.kt"); + } + + @Test + @TestMetadata("typeInComparison.kt") + public void testTypeInComparison() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/typeInComparison.kt"); + } + + @Test + @TestMetadata("unstableToStable.kt") + public void testUnstableToStable() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/unstableToStable.kt"); + } + + @Test + @TestMetadata("unstableToStableTypes.kt") + public void testUnstableToStableTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/unstableToStableTypes.kt"); + } + + @Test + @TestMetadata("varChangedInInitializer.kt") + public void testVarChangedInInitializer() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varChangedInInitializer.kt"); + } + + @Test + @TestMetadata("varChangedInLocalInitializer.kt") + public void testVarChangedInLocalInitializer() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varChangedInLocalInitializer.kt"); + } + + @Test + @TestMetadata("varInAccessor.kt") + public void testVarInAccessor() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varInAccessor.kt"); + } + + @Test + @TestMetadata("varInInitNoPrimary.kt") + public void testVarInInitNoPrimary() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varInInitNoPrimary.kt"); + } + + @Test + @TestMetadata("varInInitializer.kt") + public void testVarInInitializer() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varInInitializer.kt"); + } + + @Test + @TestMetadata("varInSecondaryConstructor.kt") + public void testVarInSecondaryConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varInSecondaryConstructor.kt"); + } + + @Test + @TestMetadata("varInsideLocalFun.kt") + public void testVarInsideLocalFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varInsideLocalFun.kt"); + } + + @Test + @TestMetadata("whenExprNonNull.kt") + public void testWhenExprNonNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/whenExprNonNull.kt"); + } + + @Test + @TestMetadata("whenIfExprNonNull.kt") + public void testWhenIfExprNonNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/whenIfExprNonNull.kt"); + } + + @Test + @TestMetadata("whenSubjectImpossible.kt") + public void testWhenSubjectImpossible() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/whenSubjectImpossible.kt"); + } + + @Test + @TestMetadata("whenSubjectImpossibleJava.kt") + public void testWhenSubjectImpossibleJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/whenSubjectImpossibleJava.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/castchecks") + @TestDataPath("$PROJECT_ROOT") + public class Castchecks { + @Test + public void testAllFilesPresentInCastchecks() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/castchecks"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("basicOn.kt") + public void testBasicOn() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/castchecks/basicOn.kt"); + } + + @Test + @TestMetadata("castInTryWithCatch.kt") + public void testCastInTryWithCatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/castchecks/castInTryWithCatch.kt"); + } + + @Test + @TestMetadata("castInTryWithoutCatch.kt") + public void testCastInTryWithoutCatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/castchecks/castInTryWithoutCatch.kt"); + } + + @Test + @TestMetadata("impossible.kt") + public void testImpossible() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/castchecks/impossible.kt"); + } + + @Test + @TestMetadata("insideCall.kt") + public void testInsideCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/castchecks/insideCall.kt"); + } + + @Test + @TestMetadata("smartCastOfNullableExpressionWithExpectedType.kt") + public void testSmartCastOfNullableExpressionWithExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/castchecks/smartCastOfNullableExpressionWithExpectedType.kt"); + } + + @Test + @TestMetadata("variables.kt") + public void testVariables() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/castchecks/variables.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/elvis") + @TestDataPath("$PROJECT_ROOT") + public class Elvis { + @Test + public void testAllFilesPresentInElvis() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/elvis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("basicOff.kt") + public void testBasicOff() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/elvis/basicOff.kt"); + } + + @Test + @TestMetadata("basicOn.kt") + public void testBasicOn() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/elvis/basicOn.kt"); + } + + @Test + @TestMetadata("impossible.kt") + public void testImpossible() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/elvis/impossible.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/inference") + @TestDataPath("$PROJECT_ROOT") + public class Inference { + @Test + public void testAllFilesPresentInInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/inference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("dependentOnPrevArg.kt") + public void testDependentOnPrevArg() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/inference/dependentOnPrevArg.kt"); + } + + @Test + @TestMetadata("intersectionTypes.kt") + public void testIntersectionTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/inference/intersectionTypes.kt"); + } + + @Test + @TestMetadata("kt1275.kt") + public void testKt1275() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/inference/kt1275.kt"); + } + + @Test + @TestMetadata("kt1355.kt") + public void testKt1355() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/inference/kt1355.kt"); + } + + @Test + @TestMetadata("kt25432.kt") + public void testKt25432() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/inference/kt25432.kt"); + } + + @Test + @TestMetadata("kt2746.kt") + public void testKt2746() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/inference/kt2746.kt"); + } + + @Test + @TestMetadata("kt2851.kt") + public void testKt2851() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/inference/kt2851.kt"); + } + + @Test + @TestMetadata("kt29767.kt") + public void testKt29767() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/inference/kt29767.kt"); + } + + @Test + @TestMetadata("kt39010.kt") + public void testKt39010() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/inference/kt39010.kt"); + } + + @Test + @TestMetadata("kt39010_2.kt") + public void testKt39010_2() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/inference/kt39010_2.kt"); + } + + @Test + @TestMetadata("kt4009.kt") + public void testKt4009() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/inference/kt4009.kt"); + } + + @Test + @TestMetadata("kt4403.kt") + public void testKt4403() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/inference/kt4403.kt"); + } + + @Test + @TestMetadata("kt4415.kt") + public void testKt4415() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/inference/kt4415.kt"); + } + + @Test + @TestMetadata("kt6242.kt") + public void testKt6242() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/inference/kt6242.kt"); + } + + @Test + @TestMetadata("smartCastOnReceiver.kt") + public void testSmartCastOnReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/inference/smartCastOnReceiver.kt"); + } + + @Test + @TestMetadata("stabilityOfSmartcastsAgainstGenericFunctions.kt") + public void testStabilityOfSmartcastsAgainstGenericFunctions() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/inference/stabilityOfSmartcastsAgainstGenericFunctions.kt"); + } + + @Test + @TestMetadata("syntheticPropertyOnUnstableSmartcast.kt") + public void testSyntheticPropertyOnUnstableSmartcast() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/inference/syntheticPropertyOnUnstableSmartcast.kt"); + } + + @Test + @TestMetadata("unneededUnstableSmartcast.kt") + public void testUnneededUnstableSmartcast() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/inference/unneededUnstableSmartcast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/intersectionScope") + @TestDataPath("$PROJECT_ROOT") + public class IntersectionScope { + @Test + public void testAllFilesPresentInIntersectionScope() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/intersectionScope"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("capturedSpecificity.kt") + public void testCapturedSpecificity() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/capturedSpecificity.kt"); + } + + @Test + @TestMetadata("conflictTypeParameters.kt") + public void testConflictTypeParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/conflictTypeParameters.kt"); + } + + @Test + @TestMetadata("conflictingReturnType.kt") + public void testConflictingReturnType() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/conflictingReturnType.kt"); + } + + @Test + @TestMetadata("flexibleTypes.kt") + public void testFlexibleTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/flexibleTypes.kt"); + } + + @Test + @TestMetadata("intersectReturnType.kt") + public void testIntersectReturnType() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/intersectReturnType.kt"); + } + + @Test + @TestMetadata("moreSpecificSetter.kt") + public void testMoreSpecificSetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/moreSpecificSetter.kt"); + } + + @Test + @TestMetadata("moreSpecificVisibility.kt") + public void testMoreSpecificVisibility() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/moreSpecificVisibility.kt"); + } + + @Test + @TestMetadata("mostSpecific.kt") + public void testMostSpecific() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/mostSpecific.kt"); + } + + @Test + @TestMetadata("mostSpecificIrrelevant.kt") + public void testMostSpecificIrrelevant() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/mostSpecificIrrelevant.kt"); + } + + @Test + @TestMetadata("properties.kt") + public void testProperties() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/properties.kt"); + } + + @Test + @TestMetadata("propertiesConflict.kt") + public void testPropertiesConflict() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/propertiesConflict.kt"); + } + + @Test + @TestMetadata("refineReturnType.kt") + public void testRefineReturnType() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/refineReturnType.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/simple.kt"); + } + + @Test + @TestMetadata("unstableSmartCast.kt") + public void testUnstableSmartCast() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/unstableSmartCast.kt"); + } + + @Test + @TestMetadata("validTypeParameters.kt") + public void testValidTypeParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/validTypeParameters.kt"); + } + + @Test + @TestMetadata("validTypeParametersNoSmartCast.kt") + public void testValidTypeParametersNoSmartCast() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/validTypeParametersNoSmartCast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/loops") + @TestDataPath("$PROJECT_ROOT") + public class Loops { + @Test + public void testAllFilesPresentInLoops() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/loops"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("assignElvisIfBreakInsideWhileTrue.kt") + public void testAssignElvisIfBreakInsideWhileTrue() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/assignElvisIfBreakInsideWhileTrue.kt"); + } + + @Test + @TestMetadata("assignWhenInsideWhileTrue.kt") + public void testAssignWhenInsideWhileTrue() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/assignWhenInsideWhileTrue.kt"); + } + + @Test + @TestMetadata("callBreakBetweenInsideDoWhile.kt") + public void testCallBreakBetweenInsideDoWhile() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/callBreakBetweenInsideDoWhile.kt"); + } + + @Test + @TestMetadata("callBreakFirstInsideDoWhile.kt") + public void testCallBreakFirstInsideDoWhile() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/callBreakFirstInsideDoWhile.kt"); + } + + @Test + @TestMetadata("callBreakInsideDoWhile.kt") + public void testCallBreakInsideDoWhile() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/callBreakInsideDoWhile.kt"); + } + + @Test + @TestMetadata("callBreakSecondInsideDoWhile.kt") + public void testCallBreakSecondInsideDoWhile() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/callBreakSecondInsideDoWhile.kt"); + } + + @Test + @TestMetadata("callBreakThirdInsideDoWhile.kt") + public void testCallBreakThirdInsideDoWhile() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/callBreakThirdInsideDoWhile.kt"); + } + + @Test + @TestMetadata("doWhile.kt") + public void testDoWhile() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/doWhile.kt"); + } + + @Test + @TestMetadata("doWhileBreak.kt") + public void testDoWhileBreak() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileBreak.kt"); + } + + @Test + @TestMetadata("doWhileContinue.kt") + public void testDoWhileContinue() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileContinue.kt"); + } + + @Test + @TestMetadata("doWhileEarlyBreak.kt") + public void testDoWhileEarlyBreak() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileEarlyBreak.kt"); + } + + @Test + @TestMetadata("doWhileEarlyContinue.kt") + public void testDoWhileEarlyContinue() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileEarlyContinue.kt"); + } + + @Test + @TestMetadata("doWhileInCondition.kt") + public void testDoWhileInCondition() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileInCondition.kt"); + } + + @Test + @TestMetadata("doWhileInConditionWithBreak.kt") + public void testDoWhileInConditionWithBreak() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileInConditionWithBreak.kt"); + } + + @Test + @TestMetadata("doWhileLiteral.kt") + public void testDoWhileLiteral() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileLiteral.kt"); + } + + @Test + @TestMetadata("doWhileNotNullBreak.kt") + public void testDoWhileNotNullBreak() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileNotNullBreak.kt"); + } + + @Test + @TestMetadata("doWhileNull.kt") + public void testDoWhileNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileNull.kt"); + } + + @Test + @TestMetadata("doWhileNullWithBreak.kt") + public void testDoWhileNullWithBreak() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileNullWithBreak.kt"); + } + + @Test + @TestMetadata("elvisBreakInsideDoWhile.kt") + public void testElvisBreakInsideDoWhile() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/elvisBreakInsideDoWhile.kt"); + } + + @Test + @TestMetadata("elvisIfBreakInsideWhileTrue.kt") + public void testElvisIfBreakInsideWhileTrue() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/elvisIfBreakInsideWhileTrue.kt"); + } + + @Test + @TestMetadata("elvisInsideDoWhile.kt") + public void testElvisInsideDoWhile() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/elvisInsideDoWhile.kt"); + } + + @Test + @TestMetadata("elvisLeftBreakInsideWhileTrue.kt") + public void testElvisLeftBreakInsideWhileTrue() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/elvisLeftBreakInsideWhileTrue.kt"); + } + + @Test + @TestMetadata("ifBlockInsideDoWhile.kt") + public void testIfBlockInsideDoWhile() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/ifBlockInsideDoWhile.kt"); + } + + @Test + @TestMetadata("ifBreakAssignInsideDoWhile.kt") + public void testIfBreakAssignInsideDoWhile() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/ifBreakAssignInsideDoWhile.kt"); + } + + @Test + @TestMetadata("ifBreakAssignInsideWhileTrue.kt") + public void testIfBreakAssignInsideWhileTrue() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/ifBreakAssignInsideWhileTrue.kt"); + } + + @Test + @TestMetadata("ifBreakExprInsideWhileTrue.kt") + public void testIfBreakExprInsideWhileTrue() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/ifBreakExprInsideWhileTrue.kt"); + } + + @Test + @TestMetadata("ifElseBlockInsideDoWhile.kt") + public void testIfElseBlockInsideDoWhile() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/ifElseBlockInsideDoWhile.kt"); + } + + @Test + @TestMetadata("ifInsideDoWhile.kt") + public void testIfInsideDoWhile() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/ifInsideDoWhile.kt"); + } + + @Test + @TestMetadata("leftElvisBreakInsideWhileTrue.kt") + public void testLeftElvisBreakInsideWhileTrue() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/leftElvisBreakInsideWhileTrue.kt"); + } + + @Test + @TestMetadata("nestedDoWhile.kt") + public void testNestedDoWhile() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/nestedDoWhile.kt"); + } + + @Test + @TestMetadata("nestedDoWhileWithLongContinue.kt") + public void testNestedDoWhileWithLongContinue() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/nestedDoWhileWithLongContinue.kt"); + } + + @Test + @TestMetadata("nestedLoops.kt") + public void testNestedLoops() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/nestedLoops.kt"); + } + + @Test + @TestMetadata("nestedLoopsShort.kt") + public void testNestedLoopsShort() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/nestedLoopsShort.kt"); + } + + @Test + @TestMetadata("nestedLoopsWithBreak.kt") + public void testNestedLoopsWithBreak() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/nestedLoopsWithBreak.kt"); + } + + @Test + @TestMetadata("nestedLoopsWithLongBreak.kt") + public void testNestedLoopsWithLongBreak() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/nestedLoopsWithLongBreak.kt"); + } + + @Test + @TestMetadata("nestedLoopsWithLongContinue.kt") + public void testNestedLoopsWithLongContinue() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/nestedLoopsWithLongContinue.kt"); + } + + @Test + @TestMetadata("plusAssignWhenInsideDoWhile.kt") + public void testPlusAssignWhenInsideDoWhile() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/plusAssignWhenInsideDoWhile.kt"); + } + + @Test + @TestMetadata("safeCallBreakInsideDoWhile.kt") + public void testSafeCallBreakInsideDoWhile() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/safeCallBreakInsideDoWhile.kt"); + } + + @Test + @TestMetadata("safeCallInsideDoWhile.kt") + public void testSafeCallInsideDoWhile() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/safeCallInsideDoWhile.kt"); + } + + @Test + @TestMetadata("useInsideDoWhile.kt") + public void testUseInsideDoWhile() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/useInsideDoWhile.kt"); + } + + @Test + @TestMetadata("whenInsideWhileTrue.kt") + public void testWhenInsideWhileTrue() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whenInsideWhileTrue.kt"); + } + + @Test + @TestMetadata("whenReturnInsideWhileTrue.kt") + public void testWhenReturnInsideWhileTrue() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whenReturnInsideWhileTrue.kt"); + } + + @Test + @TestMetadata("whileInCondition.kt") + public void testWhileInCondition() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whileInCondition.kt"); + } + + @Test + @TestMetadata("whileInConditionWithBreak.kt") + public void testWhileInConditionWithBreak() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whileInConditionWithBreak.kt"); + } + + @Test + @TestMetadata("whileNull.kt") + public void testWhileNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whileNull.kt"); + } + + @Test + @TestMetadata("whileNullAssignToSomething.kt") + public void testWhileNullAssignToSomething() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whileNullAssignToSomething.kt"); + } + + @Test + @TestMetadata("whileNullWithBreak.kt") + public void testWhileNullWithBreak() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whileNullWithBreak.kt"); + } + + @Test + @TestMetadata("whileSimple.kt") + public void testWhileSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whileSimple.kt"); + } + + @Test + @TestMetadata("whileTrivial.kt") + public void testWhileTrivial() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whileTrivial.kt"); + } + + @Test + @TestMetadata("whileTrue.kt") + public void testWhileTrue() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whileTrue.kt"); + } + + @Test + @TestMetadata("whileTrueBreakReturn.kt") + public void testWhileTrueBreakReturn() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whileTrueBreakReturn.kt"); + } + + @Test + @TestMetadata("whileTrueEarlyBreak.kt") + public void testWhileTrueEarlyBreak() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whileTrueEarlyBreak.kt"); + } + + @Test + @TestMetadata("whileTrueReturn.kt") + public void testWhileTrueReturn() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whileTrueReturn.kt"); + } + + @Test + @TestMetadata("WhileTrueWithBreakInIfCondition.kt") + public void testWhileTrueWithBreakInIfCondition() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/WhileTrueWithBreakInIfCondition.kt"); + } + + @Test + @TestMetadata("whileWithAssertInConditionAndBreak.kt") + public void testWhileWithAssertInConditionAndBreak() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whileWithAssertInConditionAndBreak.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/objectLiterals") + @TestDataPath("$PROJECT_ROOT") + public class ObjectLiterals { + @Test + public void testAllFilesPresentInObjectLiterals() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/objectLiterals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("assignment.kt") + public void testAssignment() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/objectLiterals/assignment.kt"); + } + + @Test + @TestMetadata("base.kt") + public void testBase() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/objectLiterals/base.kt"); + } + + @Test + @TestMetadata("captured.kt") + public void testCaptured() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/objectLiterals/captured.kt"); + } + + @Test + @TestMetadata("exclexcl.kt") + public void testExclexcl() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/objectLiterals/exclexcl.kt"); + } + + @Test + @TestMetadata("exclexclArgument.kt") + public void testExclexclArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/objectLiterals/exclexclArgument.kt"); + } + + @Test + @TestMetadata("exclexclTwoArgument.kt") + public void testExclexclTwoArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/objectLiterals/exclexclTwoArgument.kt"); + } + + @Test + @TestMetadata("kt7110.kt") + public void testKt7110() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/objectLiterals/kt7110.kt"); + } + + @Test + @TestMetadata("receiver.kt") + public void testReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/objectLiterals/receiver.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/publicVals") + @TestDataPath("$PROJECT_ROOT") + public class PublicVals { + @Test + public void testAllFilesPresentInPublicVals() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/publicVals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("customGetter.kt") + public void testCustomGetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/publicVals/customGetter.kt"); + } + + @Test + @TestMetadata("delegate.kt") + public void testDelegate() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/publicVals/delegate.kt"); + } + + @Test + @TestMetadata("kt4409.kt") + public void testKt4409() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/publicVals/kt4409.kt"); + } + + @Test + @TestMetadata("kt5502.kt") + public void testKt5502() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/publicVals/kt5502.kt"); + } + + @Test + @TestMetadata("open.kt") + public void testOpen() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/publicVals/open.kt"); + } + + @Test + @TestMetadata("otherModule.kt") + public void testOtherModule() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/publicVals/otherModule.kt"); + } + + @Test + @TestMetadata("otherModuleInheritance.kt") + public void testOtherModuleInheritance() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/publicVals/otherModuleInheritance.kt"); + } + + @Test + @TestMetadata("otherModuleInheritance_after.kt") + public void testOtherModuleInheritance_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/publicVals/otherModuleInheritance_after.kt"); + } + + @Test + @TestMetadata("protected.kt") + public void testProtected() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/publicVals/protected.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/publicVals/simple.kt"); + } + + @Test + @TestMetadata("var.kt") + public void testVar() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/publicVals/var.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls") + @TestDataPath("$PROJECT_ROOT") + public class Safecalls { + @Test + public void testAllFilesPresentInSafecalls() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/safecalls"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("anotherVal.kt") + public void testAnotherVal() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/anotherVal.kt"); + } + + @Test + @TestMetadata("argument.kt") + public void testArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/argument.kt"); + } + + @Test + @TestMetadata("chainAndUse.kt") + public void testChainAndUse() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/chainAndUse.kt"); + } + + @Test + @TestMetadata("chainInChain.kt") + public void testChainInChain() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/chainInChain.kt"); + } + + @Test + @TestMetadata("chainMixedUnsafe.kt") + public void testChainMixedUnsafe() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/chainMixedUnsafe.kt"); + } + + @Test + @TestMetadata("doubleCall.kt") + public void testDoubleCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/doubleCall.kt"); + } + + @Test + @TestMetadata("extension.kt") + public void testExtension() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/extension.kt"); + } + + @Test + @TestMetadata("extensionCall.kt") + public void testExtensionCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/extensionCall.kt"); + } + + @Test + @TestMetadata("falseArgument.kt") + public void testFalseArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/falseArgument.kt"); + } + + @Test + @TestMetadata("falseChain.kt") + public void testFalseChain() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/falseChain.kt"); + } + + @Test + @TestMetadata("falseExtension.kt") + public void testFalseExtension() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/falseExtension.kt"); + } + + @Test + @TestMetadata("falseSecondArgument.kt") + public void testFalseSecondArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/falseSecondArgument.kt"); + } + + @Test + @TestMetadata("innerReceiver.kt") + public void testInnerReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/innerReceiver.kt"); + } + + @Test + @TestMetadata("insideCall.kt") + public void testInsideCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/insideCall.kt"); + } + + @Test + @TestMetadata("insideIfExpr.kt") + public void testInsideIfExpr() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/insideIfExpr.kt"); + } + + @Test + @TestMetadata("longChain.kt") + public void testLongChain() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/longChain.kt"); + } + + @Test + @TestMetadata("nullableReceiver.kt") + public void testNullableReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/nullableReceiver.kt"); + } + + @Test + @TestMetadata("nullableReceiverInLongChain.kt") + public void testNullableReceiverInLongChain() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/nullableReceiverInLongChain.kt"); + } + + @Test + @TestMetadata("nullableReceiverWithExclExcl.kt") + public void testNullableReceiverWithExclExcl() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/nullableReceiverWithExclExcl.kt"); + } + + @Test + @TestMetadata("nullableReceiverWithFlexible.kt") + public void testNullableReceiverWithFlexible() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/nullableReceiverWithFlexible.kt"); + } + + @Test + @TestMetadata("property.kt") + public void testProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/property.kt"); + } + + @Test + @TestMetadata("propertyChain.kt") + public void testPropertyChain() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/propertyChain.kt"); + } + + @Test + @TestMetadata("receiver.kt") + public void testReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/receiver.kt"); + } + + @Test + @TestMetadata("receiverAndChain.kt") + public void testReceiverAndChain() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/receiverAndChain.kt"); + } + + @Test + @TestMetadata("receiverAndChainFalse.kt") + public void testReceiverAndChainFalse() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/receiverAndChainFalse.kt"); + } + + @Test + @TestMetadata("safeCallIsAlwaysNullable.kt") + public void testSafeCallIsAlwaysNullable() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/safeCallIsAlwaysNullable.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/simple.kt"); + } + + @Test + @TestMetadata("simpleNullableReceiver.kt") + public void testSimpleNullableReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/simpleNullableReceiver.kt"); + } + + @Test + @TestMetadata("twoArgs.kt") + public void testTwoArgs() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/twoArgs.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/variables") + @TestDataPath("$PROJECT_ROOT") + public class Variables { + @Test + @TestMetadata("accessorAndFunction.kt") + public void testAccessorAndFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/accessorAndFunction.kt"); + } + + @Test + @TestMetadata("aliasing.kt") + public void testAliasing() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/aliasing.kt"); + } + + @Test + public void testAllFilesPresentInVariables() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/variables"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("assignment.kt") + public void testAssignment() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/assignment.kt"); + } + + @Test + @TestMetadata("assignmentConversion.kt") + public void testAssignmentConversion() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/assignmentConversion.kt"); + } + + @Test + @TestMetadata("capturedByAtLeastOnce.kt") + public void testCapturedByAtLeastOnce() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/capturedByAtLeastOnce.kt"); + } + + @Test + @TestMetadata("capturedByMultipleLambdas.kt") + public void testCapturedByMultipleLambdas() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/capturedByMultipleLambdas.kt"); + } + + @Test + @TestMetadata("capturedByNested.kt") + public void testCapturedByNested() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/capturedByNested.kt"); + } + + @Test + @TestMetadata("capturedLoopVariable.kt") + public void testCapturedLoopVariable() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/capturedLoopVariable.kt"); + } + + @Test + @TestMetadata("capturedWithControlJumps.kt") + public void testCapturedWithControlJumps() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/capturedWithControlJumps.kt"); + } + + @Test + @TestMetadata("doWhileWithMiddleBreak.kt") + public void testDoWhileWithMiddleBreak() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/doWhileWithMiddleBreak.kt"); + } + + @Test + @TestMetadata("ifElseBlockInsideDoWhile.kt") + public void testIfElseBlockInsideDoWhile() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/ifElseBlockInsideDoWhile.kt"); + } + + @Test + @TestMetadata("ifElseBlockInsideDoWhileWithBreak.kt") + public void testIfElseBlockInsideDoWhileWithBreak() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/ifElseBlockInsideDoWhileWithBreak.kt"); + } + + @Test + @TestMetadata("ifNullAssignment.kt") + public void testIfNullAssignment() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/ifNullAssignment.kt"); + } + + @Test + @TestMetadata("ifVarIs.kt") + public void testIfVarIs() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/ifVarIs.kt"); + } + + @Test + @TestMetadata("ifVarIsAnd.kt") + public void testIfVarIsAnd() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/ifVarIsAnd.kt"); + } + + @Test + @TestMetadata("ifVarIsChanged.kt") + public void testIfVarIsChanged() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/ifVarIsChanged.kt"); + } + + @Test + @TestMetadata("inPropertySam.kt") + public void testInPropertySam() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/inPropertySam.kt"); + } + + @Test + @TestMetadata("infix.kt") + public void testInfix() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/infix.kt"); + } + + @Test + @TestMetadata("initialization.kt") + public void testInitialization() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/initialization.kt"); + } + + @Test + @TestMetadata("kt7599.kt") + public void testKt7599() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/kt7599.kt"); + } + + @Test + @TestMetadata("lambdaBetweenArguments.kt") + public void testLambdaBetweenArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/lambdaBetweenArguments.kt"); + } + + @Test + @TestMetadata("objectMembers.kt") + public void testObjectMembers() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/objectMembers.kt"); + } + + @Test + @TestMetadata("property.kt") + public void testProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/property.kt"); + } + + @Test + @TestMetadata("propertyNotNeeded.kt") + public void testPropertyNotNeeded() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/propertyNotNeeded.kt"); + } + + @Test + @TestMetadata("propertySubtype.kt") + public void testPropertySubtype() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/propertySubtype.kt"); + } + + @Test + @TestMetadata("propertySubtypeInMember.kt") + public void testPropertySubtypeInMember() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/propertySubtypeInMember.kt"); + } + + @Test + @TestMetadata("propertySubtypeInMemberCheck.kt") + public void testPropertySubtypeInMemberCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/propertySubtypeInMemberCheck.kt"); + } + + @Test + @TestMetadata("reassignedDependency.kt") + public void testReassignedDependency() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/reassignedDependency.kt"); + } + + @Test + @TestMetadata("reassignedInRhs.kt") + public void testReassignedInRhs() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/reassignedInRhs.kt"); + } + + @Test + @TestMetadata("varAsUse.kt") + public void testVarAsUse() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/varAsUse.kt"); + } + + @Test + @TestMetadata("varChangedInLoop.kt") + public void testVarChangedInLoop() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/varChangedInLoop.kt"); + } + + @Test + @TestMetadata("varNotChangedInLoop.kt") + public void testVarNotChangedInLoop() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/varNotChangedInLoop.kt"); + } + + @Test + @TestMetadata("whileTrue.kt") + public void testWhileTrue() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/whileTrue.kt"); + } + + @Test + @TestMetadata("whileWithBreak.kt") + public void testWhileWithBreak() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/variables/whileWithBreak.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull") + @TestDataPath("$PROJECT_ROOT") + public class Varnotnull { + @Test + public void testAllFilesPresentInVarnotnull() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/varnotnull"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("assignNestedWhile.kt") + public void testAssignNestedWhile() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/assignNestedWhile.kt"); + } + + @Test + @TestMetadata("assignment.kt") + public void testAssignment() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/assignment.kt"); + } + + @Test + @TestMetadata("boundInitializer.kt") + public void testBoundInitializer() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/boundInitializer.kt"); + } + + @Test + @TestMetadata("boundInitializerWrong.kt") + public void testBoundInitializerWrong() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/boundInitializerWrong.kt"); + } + + @Test + @TestMetadata("capturedInClosureModifiedBefore.kt") + public void testCapturedInClosureModifiedBefore() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/capturedInClosureModifiedBefore.kt"); + } + + @Test + @TestMetadata("doWhileWithBreak.kt") + public void testDoWhileWithBreak() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/doWhileWithBreak.kt"); + } + + @Test + @TestMetadata("doWhileWithMiddleBreak.kt") + public void testDoWhileWithMiddleBreak() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/doWhileWithMiddleBreak.kt"); + } + + @Test + @TestMetadata("forEach.kt") + public void testForEach() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEach.kt"); + } + + @Test + @TestMetadata("forEachWithBreak.kt") + public void testForEachWithBreak() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEachWithBreak.kt"); + } + + @Test + @TestMetadata("forEachWithContinue.kt") + public void testForEachWithContinue() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEachWithContinue.kt"); + } + + @Test + @TestMetadata("ifVarNotNull.kt") + public void testIfVarNotNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/ifVarNotNull.kt"); + } + + @Test + @TestMetadata("ifVarNotNullAnd.kt") + public void testIfVarNotNullAnd() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/ifVarNotNullAnd.kt"); + } + + @Test + @TestMetadata("ifVarNullElse.kt") + public void testIfVarNullElse() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/ifVarNullElse.kt"); + } + + @Test + @TestMetadata("ifVarNullReturn.kt") + public void testIfVarNullReturn() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/ifVarNullReturn.kt"); + } + + @Test + @TestMetadata("inference.kt") + public void testInference() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/inference.kt"); + } + + @Test + @TestMetadata("infiniteWhileWithBreak.kt") + public void testInfiniteWhileWithBreak() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/infiniteWhileWithBreak.kt"); + } + + @Test + @TestMetadata("infix.kt") + public void testInfix() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/infix.kt"); + } + + @Test + @TestMetadata("initInTryReturnInCatch.kt") + public void testInitInTryReturnInCatch() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/initInTryReturnInCatch.kt"); + } + + @Test + @TestMetadata("initialization.kt") + public void testInitialization() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/initialization.kt"); + } + + @Test + @TestMetadata("iterations.kt") + public void testIterations() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/iterations.kt"); + } + + @Test + @TestMetadata("leakingLambdaInCalledInPlace.kt") + public void testLeakingLambdaInCalledInPlace() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/leakingLambdaInCalledInPlace.kt"); + } + + @Test + @TestMetadata("nestedDoWhile.kt") + public void testNestedDoWhile() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/nestedDoWhile.kt"); + } + + @Test + @TestMetadata("nestedLoops.kt") + public void testNestedLoops() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/nestedLoops.kt"); + } + + @Test + @TestMetadata("nestedWhile.kt") + public void testNestedWhile() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/nestedWhile.kt"); + } + + @Test + @TestMetadata("plusplusMinusminus.kt") + public void testPlusplusMinusminus() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/plusplusMinusminus.kt"); + } + + @Test + @TestMetadata("postfixNotnullClassIncrement.kt") + public void testPostfixNotnullClassIncrement() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/postfixNotnullClassIncrement.kt"); + } + + @Test + @TestMetadata("postfixNullableClassIncrement.kt") + public void testPostfixNullableClassIncrement() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/postfixNullableClassIncrement.kt"); + } + + @Test + @TestMetadata("postfixNullableIncrement.kt") + public void testPostfixNullableIncrement() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/postfixNullableIncrement.kt"); + } + + @Test + @TestMetadata("prefixNotnullClassIncrement.kt") + public void testPrefixNotnullClassIncrement() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/prefixNotnullClassIncrement.kt"); + } + + @Test + @TestMetadata("prefixNullableClassIncrement.kt") + public void testPrefixNullableClassIncrement() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/prefixNullableClassIncrement.kt"); + } + + @Test + @TestMetadata("prefixNullableIncrement.kt") + public void testPrefixNullableIncrement() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/prefixNullableIncrement.kt"); + } + + @Test + @TestMetadata("setNotNullInTry.kt") + public void testSetNotNullInTry() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/setNotNullInTry.kt"); + } + + @Test + @TestMetadata("setNullInTry.kt") + public void testSetNullInTry() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/setNullInTry.kt"); + } + + @Test + @TestMetadata("setNullInTryFinally.kt") + public void testSetNullInTryFinally() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/setNullInTryFinally.kt"); + } + + @Test + @TestMetadata("setSameInTry.kt") + public void testSetSameInTry() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/setSameInTry.kt"); + } + + @Test + @TestMetadata("toFlexibleType.kt") + public void testToFlexibleType() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/toFlexibleType.kt"); + } + + @Test + @TestMetadata("unnecessary.kt") + public void testUnnecessary() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/unnecessary.kt"); + } + + @Test + @TestMetadata("unnecessaryWithBranch.kt") + public void testUnnecessaryWithBranch() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/unnecessaryWithBranch.kt"); + } + + @Test + @TestMetadata("unnecessaryWithMap.kt") + public void testUnnecessaryWithMap() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/unnecessaryWithMap.kt"); + } + + @Test + @TestMetadata("varCapturedInClosure.kt") + public void testVarCapturedInClosure() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/varCapturedInClosure.kt"); + } + + @Test + @TestMetadata("varCapturedInInlineClosure.kt") + public void testVarCapturedInInlineClosure() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/varCapturedInInlineClosure.kt"); + } + + @Test + @TestMetadata("varCapturedInSafeClosure.kt") + public void testVarCapturedInSafeClosure() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/varCapturedInSafeClosure.kt"); + } + + @Test + @TestMetadata("varChangedInLoop.kt") + public void testVarChangedInLoop() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/varChangedInLoop.kt"); + } + + @Test + @TestMetadata("varCheck.kt") + public void testVarCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/varCheck.kt"); + } + + @Test + @TestMetadata("varIntNull.kt") + public void testVarIntNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/varIntNull.kt"); + } + + @Test + @TestMetadata("varNotChangedInLoop.kt") + public void testVarNotChangedInLoop() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/varNotChangedInLoop.kt"); + } + + @Test + @TestMetadata("varNull.kt") + public void testVarNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/varNull.kt"); + } + + @Test + @TestMetadata("whileTrue.kt") + public void testWhileTrue() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/whileTrue.kt"); + } + + @Test + @TestMetadata("whileTrueWithBracketSet.kt") + public void testWhileTrueWithBracketSet() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/whileTrueWithBracketSet.kt"); + } + + @Test + @TestMetadata("whileTrueWithBrackets.kt") + public void testWhileTrueWithBrackets() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/whileTrueWithBrackets.kt"); + } + + @Test + @TestMetadata("whileWithBreak.kt") + public void testWhileWithBreak() throws Exception { + runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/whileWithBreak.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/sourceCompatibility") + @TestDataPath("$PROJECT_ROOT") + public class SourceCompatibility { + @Test + public void testAllFilesPresentInSourceCompatibility() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sourceCompatibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("noBigFunctionTypes.kt") + public void testNoBigFunctionTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/sourceCompatibility/noBigFunctionTypes.kt"); + } + + @Test + @TestMetadata("noMultiplatformProjects.kt") + public void testNoMultiplatformProjects() throws Exception { + runTest("compiler/testData/diagnostics/tests/sourceCompatibility/noMultiplatformProjects.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion") + @TestDataPath("$PROJECT_ROOT") + public class ApiVersion { + @Test + public void testAllFilesPresentInApiVersion() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("annotations.kt") + public void testAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/annotations.kt"); + } + + @Test + @TestMetadata("classesAndConstructors.kt") + public void testClassesAndConstructors() throws Exception { + runTest("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/classesAndConstructors.kt"); + } + + @Test + @TestMetadata("overriddenMembers.kt") + public void testOverriddenMembers() throws Exception { + runTest("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/overriddenMembers.kt"); + } + + @Test + @TestMetadata("propertyAccessors.kt") + public void testPropertyAccessors() throws Exception { + runTest("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/propertyAccessors.kt"); + } + + @Test + @TestMetadata("simpleMembers.kt") + public void testSimpleMembers() throws Exception { + runTest("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/simpleMembers.kt"); + } + + @Test + @TestMetadata("sinceOldVersionIsOK.kt") + public void testSinceOldVersionIsOK() throws Exception { + runTest("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/sinceOldVersionIsOK.kt"); + } + + @Test + @TestMetadata("typealiasesAsCompanionObjects.kt") + public void testTypealiasesAsCompanionObjects() throws Exception { + runTest("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/typealiasesAsCompanionObjects.kt"); + } + + @Test + @TestMetadata("typealiasesAsConstructors.kt") + public void testTypealiasesAsConstructors() throws Exception { + runTest("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/typealiasesAsConstructors.kt"); + } + + @Test + @TestMetadata("typealiasesAsObjects.kt") + public void testTypealiasesAsObjects() throws Exception { + runTest("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/typealiasesAsObjects.kt"); + } + + @Test + @TestMetadata("typealiasesAsTypes.kt") + public void testTypealiasesAsTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/typealiasesAsTypes.kt"); + } + + @Test + @TestMetadata("typealiasesOnImport.kt") + public void testTypealiasesOnImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/typealiasesOnImport.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/substitutions") + @TestDataPath("$PROJECT_ROOT") + public class Substitutions { + @Test + public void testAllFilesPresentInSubstitutions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/substitutions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("kt1558-short.kt") + public void testKt1558_short() throws Exception { + runTest("compiler/testData/diagnostics/tests/substitutions/kt1558-short.kt"); + } + + @Test + @TestMetadata("kt4887.kt") + public void testKt4887() throws Exception { + runTest("compiler/testData/diagnostics/tests/substitutions/kt4887.kt"); + } + + @Test + @TestMetadata("starProjections.kt") + public void testStarProjections() throws Exception { + runTest("compiler/testData/diagnostics/tests/substitutions/starProjections.kt"); + } + + @Test + @TestMetadata("upperBoundsSubstitutionForOverloadResolutionWithAmbiguity.kt") + public void testUpperBoundsSubstitutionForOverloadResolutionWithAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithAmbiguity.kt"); + } + + @Test + @TestMetadata("upperBoundsSubstitutionForOverloadResolutionWithErrorTypes.kt") + public void testUpperBoundsSubstitutionForOverloadResolutionWithErrorTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithErrorTypes.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/subtyping") + @TestDataPath("$PROJECT_ROOT") + public class Subtyping { + @Test + public void testAllFilesPresentInSubtyping() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/subtyping"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("delegatedConstructor.kt") + public void testDelegatedConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/subtyping/delegatedConstructor.kt"); + } + + @Test + @TestMetadata("extFunctionTypeAsSuperType.kt") + public void testExtFunctionTypeAsSuperType() throws Exception { + runTest("compiler/testData/diagnostics/tests/subtyping/extFunctionTypeAsSuperType.kt"); + } + + @Test + @TestMetadata("extFunctionTypeAsSuperTypeRestrictionLifted.kt") + public void testExtFunctionTypeAsSuperTypeRestrictionLifted() throws Exception { + runTest("compiler/testData/diagnostics/tests/subtyping/extFunctionTypeAsSuperTypeRestrictionLifted.kt"); + } + + @Test + @TestMetadata("findClosestCorrespondingSupertype.kt") + public void testFindClosestCorrespondingSupertype() throws Exception { + runTest("compiler/testData/diagnostics/tests/subtyping/findClosestCorrespondingSupertype.kt"); + } + + @Test + @TestMetadata("functionTypeAsSuperType.kt") + public void testFunctionTypeAsSuperType() throws Exception { + runTest("compiler/testData/diagnostics/tests/subtyping/functionTypeAsSuperType.kt"); + } + + @Test + @TestMetadata("invariantArgumentForTypeParameterWithMultipleBounds.kt") + public void testInvariantArgumentForTypeParameterWithMultipleBounds() throws Exception { + runTest("compiler/testData/diagnostics/tests/subtyping/invariantArgumentForTypeParameterWithMultipleBounds.kt"); + } + + @Test + @TestMetadata("javaAndKotlinSuperType.kt") + public void testJavaAndKotlinSuperType() throws Exception { + runTest("compiler/testData/diagnostics/tests/subtyping/javaAndKotlinSuperType.kt"); + } + + @Test + @TestMetadata("kt2069.kt") + public void testKt2069() throws Exception { + runTest("compiler/testData/diagnostics/tests/subtyping/kt2069.kt"); + } + + @Test + @TestMetadata("kt2744.kt") + public void testKt2744() throws Exception { + runTest("compiler/testData/diagnostics/tests/subtyping/kt2744.kt"); + } + + @Test + @TestMetadata("kt304.kt") + public void testKt304() throws Exception { + runTest("compiler/testData/diagnostics/tests/subtyping/kt304.kt"); + } + + @Test + @TestMetadata("kt3159.kt") + public void testKt3159() throws Exception { + runTest("compiler/testData/diagnostics/tests/subtyping/kt3159.kt"); + } + + @Test + @TestMetadata("kt47148.kt") + public void testKt47148() throws Exception { + runTest("compiler/testData/diagnostics/tests/subtyping/kt47148.kt"); + } + + @Test + @TestMetadata("kt-1457.kt") + public void testKt_1457() throws Exception { + runTest("compiler/testData/diagnostics/tests/subtyping/kt-1457.kt"); + } + + @Test + @TestMetadata("localAnonymousObjects.kt") + public void testLocalAnonymousObjects() throws Exception { + runTest("compiler/testData/diagnostics/tests/subtyping/localAnonymousObjects.kt"); + } + + @Test + @TestMetadata("localClasses.kt") + public void testLocalClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/subtyping/localClasses.kt"); + } + + @Test + @TestMetadata("memberAnonymousObjects.kt") + public void testMemberAnonymousObjects() throws Exception { + runTest("compiler/testData/diagnostics/tests/subtyping/memberAnonymousObjects.kt"); + } + + @Test + @TestMetadata("nestedIntoLocalClasses.kt") + public void testNestedIntoLocalClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/subtyping/nestedIntoLocalClasses.kt"); + } + + @Test + @TestMetadata("nestedLocalClasses.kt") + public void testNestedLocalClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/subtyping/nestedLocalClasses.kt"); + } + + @Test + @TestMetadata("topLevelAnonymousObjects.kt") + public void testTopLevelAnonymousObjects() throws Exception { + runTest("compiler/testData/diagnostics/tests/subtyping/topLevelAnonymousObjects.kt"); + } + + @Test + @TestMetadata("unresolvedSupertype.kt") + public void testUnresolvedSupertype() throws Exception { + runTest("compiler/testData/diagnostics/tests/subtyping/unresolvedSupertype.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/suppress") + @TestDataPath("$PROJECT_ROOT") + public class Suppress { + @Test + public void testAllFilesPresentInSuppress() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/suppress/allWarnings") + @TestDataPath("$PROJECT_ROOT") + public class AllWarnings { + @Test + public void testAllFilesPresentInAllWarnings() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress/allWarnings"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("suppressWarningsOnAnonymousObjectInVariable.kt") + public void testSuppressWarningsOnAnonymousObjectInVariable() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnAnonymousObjectInVariable.kt"); + } + + @Test + @TestMetadata("suppressWarningsOnClass.kt") + public void testSuppressWarningsOnClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnClass.kt"); + } + + @Test + @TestMetadata("suppressWarningsOnClassObject.kt") + public void testSuppressWarningsOnClassObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnClassObject.kt"); + } + + @Test + @TestMetadata("suppressWarningsOnExpression.kt") + public void testSuppressWarningsOnExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnExpression.kt"); + } + + @Test + @TestMetadata("suppressWarningsOnFile.kt") + public void testSuppressWarningsOnFile() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnFile.kt"); + } + + @Test + @TestMetadata("suppressWarningsOnFunction.kt") + public void testSuppressWarningsOnFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnFunction.kt"); + } + + @Test + @TestMetadata("suppressWarningsOnObject.kt") + public void testSuppressWarningsOnObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnObject.kt"); + } + + @Test + @TestMetadata("suppressWarningsOnParameter.kt") + public void testSuppressWarningsOnParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnParameter.kt"); + } + + @Test + @TestMetadata("suppressWarningsOnProperty.kt") + public void testSuppressWarningsOnProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnProperty.kt"); + } + + @Test + @TestMetadata("suppressWarningsOnPropertyAccessor.kt") + public void testSuppressWarningsOnPropertyAccessor() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnPropertyAccessor.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/suppress/manyWarnings") + @TestDataPath("$PROJECT_ROOT") + public class ManyWarnings { + @Test + public void testAllFilesPresentInManyWarnings() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress/manyWarnings"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("mixed.kt") + public void testMixed() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/manyWarnings/mixed.kt"); + } + + @Test + @TestMetadata("onClass.kt") + public void testOnClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/manyWarnings/onClass.kt"); + } + + @Test + @TestMetadata("onClassObject.kt") + public void testOnClassObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/manyWarnings/onClassObject.kt"); + } + + @Test + @TestMetadata("onExpression.kt") + public void testOnExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/manyWarnings/onExpression.kt"); + } + + @Test + @TestMetadata("onFunction.kt") + public void testOnFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/manyWarnings/onFunction.kt"); + } + + @Test + @TestMetadata("onObject.kt") + public void testOnObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/manyWarnings/onObject.kt"); + } + + @Test + @TestMetadata("onParameter.kt") + public void testOnParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/manyWarnings/onParameter.kt"); + } + + @Test + @TestMetadata("onProperty.kt") + public void testOnProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/manyWarnings/onProperty.kt"); + } + + @Test + @TestMetadata("onPropertyAccessor.kt") + public void testOnPropertyAccessor() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/manyWarnings/onPropertyAccessor.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/suppress/oneWarning") + @TestDataPath("$PROJECT_ROOT") + public class OneWarning { + @Test + public void testAllFilesPresentInOneWarning() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress/oneWarning"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("onBlockStatement.kt") + public void testOnBlockStatement() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/oneWarning/onBlockStatement.kt"); + } + + @Test + @TestMetadata("onBlockStatementSameLine.kt") + public void testOnBlockStatementSameLine() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/oneWarning/onBlockStatementSameLine.kt"); + } + + @Test + @TestMetadata("onClass.kt") + public void testOnClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/oneWarning/onClass.kt"); + } + + @Test + @TestMetadata("onClassObject.kt") + public void testOnClassObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/oneWarning/onClassObject.kt"); + } + + @Test + @TestMetadata("onExpression.kt") + public void testOnExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/oneWarning/onExpression.kt"); + } + + @Test + @TestMetadata("onFunction.kt") + public void testOnFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/oneWarning/onFunction.kt"); + } + + @Test + @TestMetadata("onLocalVariable.kt") + public void testOnLocalVariable() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/oneWarning/onLocalVariable.kt"); + } + + @Test + @TestMetadata("onObject.kt") + public void testOnObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/oneWarning/onObject.kt"); + } + + @Test + @TestMetadata("onParameter.kt") + public void testOnParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/oneWarning/onParameter.kt"); + } + + @Test + @TestMetadata("onProperty.kt") + public void testOnProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/oneWarning/onProperty.kt"); + } + + @Test + @TestMetadata("onPropertyAccessor.kt") + public void testOnPropertyAccessor() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/oneWarning/onPropertyAccessor.kt"); + } + + @Test + @TestMetadata("onTypeParameter.kt") + public void testOnTypeParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/oneWarning/onTypeParameter.kt"); + } + + @Test + @TestMetadata("suppressOnDeclarationItself.kt") + public void testSuppressOnDeclarationItself() throws Exception { + runTest("compiler/testData/diagnostics/tests/suppress/oneWarning/suppressOnDeclarationItself.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/suspendConversion") + @TestDataPath("$PROJECT_ROOT") + public class SuspendConversion { + @Test + public void testAllFilesPresentInSuspendConversion() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("basicSuspendConversion.kt") + public void testBasicSuspendConversion() throws Exception { + runTest("compiler/testData/diagnostics/tests/suspendConversion/basicSuspendConversion.kt"); + } + + @Test + @TestMetadata("basicSuspendConversionForCallableReference.kt") + public void testBasicSuspendConversionForCallableReference() throws Exception { + runTest("compiler/testData/diagnostics/tests/suspendConversion/basicSuspendConversionForCallableReference.kt"); + } + + @Test + @TestMetadata("basicSuspendConversionGenerics.kt") + public void testBasicSuspendConversionGenerics() throws Exception { + runTest("compiler/testData/diagnostics/tests/suspendConversion/basicSuspendConversionGenerics.kt"); + } + + @Test + @TestMetadata("chainedFunSuspendConversionForSimpleExpression.kt") + public void testChainedFunSuspendConversionForSimpleExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/suspendConversion/chainedFunSuspendConversionForSimpleExpression.kt"); + } + + @Test + @TestMetadata("overloadResolutionBySuspendModifier.kt") + public void testOverloadResolutionBySuspendModifier() throws Exception { + runTest("compiler/testData/diagnostics/tests/suspendConversion/overloadResolutionBySuspendModifier.kt"); + } + + @Test + @TestMetadata("severalConversionsInOneCall.kt") + public void testSeveralConversionsInOneCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/suspendConversion/severalConversionsInOneCall.kt"); + } + + @Test + @TestMetadata("suspendAndFunConversionInDisabledMode.kt") + public void testSuspendAndFunConversionInDisabledMode() throws Exception { + runTest("compiler/testData/diagnostics/tests/suspendConversion/suspendAndFunConversionInDisabledMode.kt"); + } + + @Test + @TestMetadata("suspendConversionCompatibility.kt") + public void testSuspendConversionCompatibility() throws Exception { + runTest("compiler/testData/diagnostics/tests/suspendConversion/suspendConversionCompatibility.kt"); + } + + @Test + @TestMetadata("suspendConversionCompatibilityInDisabledMode.kt") + public void testSuspendConversionCompatibilityInDisabledMode() throws Exception { + runTest("compiler/testData/diagnostics/tests/suspendConversion/suspendConversionCompatibilityInDisabledMode.kt"); + } + + @Test + @TestMetadata("suspendConversionDisabled.kt") + public void testSuspendConversionDisabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/suspendConversion/suspendConversionDisabled.kt"); + } + + @Test + @TestMetadata("suspendConversionOnVarargElements.kt") + public void testSuspendConversionOnVarargElements() throws Exception { + runTest("compiler/testData/diagnostics/tests/suspendConversion/suspendConversionOnVarargElements.kt"); + } + + @Test + @TestMetadata("suspendConversionWithFunInterfaces.kt") + public void testSuspendConversionWithFunInterfaces() throws Exception { + runTest("compiler/testData/diagnostics/tests/suspendConversion/suspendConversionWithFunInterfaces.kt"); + } + + @Test + @TestMetadata("suspendConversionWithReferenceAdaptation.kt") + public void testSuspendConversionWithReferenceAdaptation() throws Exception { + runTest("compiler/testData/diagnostics/tests/suspendConversion/suspendConversionWithReferenceAdaptation.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/syntax") + @TestDataPath("$PROJECT_ROOT") + public class Syntax { + @Test + public void testAllFilesPresentInSyntax() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/syntax"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("complicatedLTGT.kt") + public void testComplicatedLTGT() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntax/complicatedLTGT.kt"); + } + + @Test + @TestMetadata("complicatedLTGTE.kt") + public void testComplicatedLTGTE() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntax/complicatedLTGTE.kt"); + } + + @Test + @TestMetadata("incorrectLTGTFallback.kt") + public void testIncorrectLTGTFallback() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntax/incorrectLTGTFallback.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/syntheticExtensions") + @TestDataPath("$PROJECT_ROOT") + public class SyntheticExtensions { + @Test + public void testAllFilesPresentInSyntheticExtensions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/syntheticExtensions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties") + @TestDataPath("$PROJECT_ROOT") + public class JavaProperties { + @Test + @TestMetadata("AbbreviationName.kt") + public void testAbbreviationName() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/AbbreviationName.kt"); + } + + @Test + public void testAllFilesPresentInJavaProperties() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("Bases.kt") + public void testBases() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/Bases.kt"); + } + + @Test + @TestMetadata("CompiledClass.kt") + public void testCompiledClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/CompiledClass.kt"); + } + + @Test + @TestMetadata("Deprecated.kt") + public void testDeprecated() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/Deprecated.kt"); + } + + @Test + @TestMetadata("FalseGetters.kt") + public void testFalseGetters() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/FalseGetters.kt"); + } + + @Test + @TestMetadata("FalseSetters.kt") + public void testFalseSetters() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/FalseSetters.kt"); + } + + @Test + @TestMetadata("FromTwoBases.kt") + public void testFromTwoBases() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/FromTwoBases.kt"); + } + + @Test + @TestMetadata("FullySupportedSyntheticJavaPropertyReference.kt") + public void testFullySupportedSyntheticJavaPropertyReference() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/FullySupportedSyntheticJavaPropertyReference.kt"); + } + + @Test + @TestMetadata("GenericClass.kt") + public void testGenericClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/GenericClass.kt"); + } + + @Test + @TestMetadata("GetA.kt") + public void testGetA() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/GetA.kt"); + } + + @Test + @TestMetadata("Getter.kt") + public void testGetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/Getter.kt"); + } + + @Test + @TestMetadata("GetterAndSetter.kt") + public void testGetterAndSetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/GetterAndSetter.kt"); + } + + @Test + @TestMetadata("ImplicitReceiver.kt") + public void testImplicitReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/ImplicitReceiver.kt"); + } + + @Test + @TestMetadata("IsNaming.kt") + public void testIsNaming() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/IsNaming.kt"); + } + + @Test + @TestMetadata("JavaOverridesKotlin.kt") + public void testJavaOverridesKotlin() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/JavaOverridesKotlin.kt"); + } + + @Test + @TestMetadata("KotlinOverridesJava.kt") + public void testKotlinOverridesJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/KotlinOverridesJava.kt"); + } + + @Test + @TestMetadata("KotlinOverridesJava2.kt") + public void testKotlinOverridesJava2() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/KotlinOverridesJava2.kt"); + } + + @Test + @TestMetadata("KotlinOverridesJava3.kt") + public void testKotlinOverridesJava3() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/KotlinOverridesJava3.kt"); + } + + @Test + @TestMetadata("KotlinOverridesJava4.kt") + public void testKotlinOverridesJava4() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/KotlinOverridesJava4.kt"); + } + + @Test + @TestMetadata("KotlinOverridesJava5.kt") + public void testKotlinOverridesJava5() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/KotlinOverridesJava5.kt"); + } + + @Test + @TestMetadata("nonAsciiSecondChar.kt") + public void testNonAsciiSecondChar() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/nonAsciiSecondChar.kt"); + } + + @Test + @TestMetadata("nonValidFirstChar.kt") + public void testNonValidFirstChar() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/nonValidFirstChar.kt"); + } + + @Test + @TestMetadata("OnlyAscii.kt") + public void testOnlyAscii() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/OnlyAscii.kt"); + } + + @Test + @TestMetadata("OnlyPublic.kt") + public void testOnlyPublic() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/OnlyPublic.kt"); + } + + @Test + @TestMetadata("OverrideGetterOnly.kt") + public void testOverrideGetterOnly() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/OverrideGetterOnly.kt"); + } + + @Test + @TestMetadata("OverrideOnlyGetterFromGenericJavaClass.kt") + public void testOverrideOnlyGetterFromGenericJavaClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/OverrideOnlyGetterFromGenericJavaClass.kt"); + } + + @Test + @TestMetadata("SetterHasHigherAccess.kt") + public void testSetterHasHigherAccess() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/SetterHasHigherAccess.kt"); + } + + @Test + @TestMetadata("SetterOnly.kt") + public void testSetterOnly() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/SetterOnly.kt"); + } + + @Test + @TestMetadata("SmartCast.kt") + public void testSmartCast() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/SmartCast.kt"); + } + + @Test + @TestMetadata("SmartCastImplicitReceiver.kt") + public void testSmartCastImplicitReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/SmartCastImplicitReceiver.kt"); + } + + @Test + @TestMetadata("SyntheticJavaPropertyReference.kt") + public void testSyntheticJavaPropertyReference() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/SyntheticJavaPropertyReference.kt"); + } + + @Test + @TestMetadata("TypeAnnotation.kt") + public void testTypeAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/TypeAnnotation.kt"); + } + + @Test + @TestMetadata("TypeParameterReceiver.kt") + public void testTypeParameterReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/TypeParameterReceiver.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters") + @TestDataPath("$PROJECT_ROOT") + public class SamAdapters { + @Test + public void testAllFilesPresentInSamAdapters() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("Deprecated.kt") + public void testDeprecated() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Deprecated.kt"); + } + + @Test + @TestMetadata("GenericClass.kt") + public void testGenericClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericClass.kt"); + } + + @Test + @TestMetadata("GenericMethod.kt") + public void testGenericMethod() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethod.kt"); + } + + @Test + @TestMetadata("GenericMethodInGenericClass.kt") + public void testGenericMethodInGenericClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethodInGenericClass.kt"); + } + + @Test + @TestMetadata("InnerClassInGeneric.kt") + public void testInnerClassInGeneric() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/InnerClassInGeneric.kt"); + } + + @Test + @TestMetadata("NoNamedArgsAllowed.kt") + public void testNoNamedArgsAllowed() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/NoNamedArgsAllowed.kt"); + } + + @Test + @TestMetadata("overloadResolution.kt") + public void testOverloadResolution() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/overloadResolution.kt"); + } + + @Test + @TestMetadata("overloadResolutionStatic.kt") + public void testOverloadResolutionStatic() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/overloadResolutionStatic.kt"); + } + + @Test + @TestMetadata("PackageLocal.kt") + public void testPackageLocal() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/PackageLocal.kt"); + } + + @Test + @TestMetadata("ParameterTypeAnnotation.kt") + public void testParameterTypeAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/ParameterTypeAnnotation.kt"); + } + + @Test + @TestMetadata("PassNull.kt") + public void testPassNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/PassNull.kt"); + } + + @Test + @TestMetadata("Private.kt") + public void testPrivate() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Private.kt"); + } + + @Test + @TestMetadata("Protected.kt") + public void testProtected() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Protected.kt"); + } + + @Test + @TestMetadata("ReturnTypeAnnotation.kt") + public void testReturnTypeAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/ReturnTypeAnnotation.kt"); + } + + @Test + @TestMetadata("Simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Simple.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/targetedBuiltIns") + @TestDataPath("$PROJECT_ROOT") + public class TargetedBuiltIns { + @Test + public void testAllFilesPresentInTargetedBuiltIns() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/targetedBuiltIns"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("concurrentMapRemove.kt") + public void testConcurrentMapRemove() throws Exception { + runTest("compiler/testData/diagnostics/tests/targetedBuiltIns/concurrentMapRemove.kt"); + } + + @Test + @TestMetadata("forEachRemainingNullability.kt") + public void testForEachRemainingNullability() throws Exception { + runTest("compiler/testData/diagnostics/tests/targetedBuiltIns/forEachRemainingNullability.kt"); + } + + @Test + @TestMetadata("getOrDefault.kt") + public void testGetOrDefault() throws Exception { + runTest("compiler/testData/diagnostics/tests/targetedBuiltIns/getOrDefault.kt"); + } + + @Test + @TestMetadata("mutableMapRemove.kt") + public void testMutableMapRemove() throws Exception { + runTest("compiler/testData/diagnostics/tests/targetedBuiltIns/mutableMapRemove.kt"); + } + + @Test + @TestMetadata("removeIf.kt") + public void testRemoveIf() throws Exception { + runTest("compiler/testData/diagnostics/tests/targetedBuiltIns/removeIf.kt"); + } + + @Test + @TestMetadata("stream.kt") + public void testStream() throws Exception { + runTest("compiler/testData/diagnostics/tests/targetedBuiltIns/stream.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/targetedBuiltIns/backwardCompatibility") + @TestDataPath("$PROJECT_ROOT") + public class BackwardCompatibility { + @Test + public void testAllFilesPresentInBackwardCompatibility() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/targetedBuiltIns/backwardCompatibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("basic.kt") + public void testBasic() throws Exception { + runTest("compiler/testData/diagnostics/tests/targetedBuiltIns/backwardCompatibility/basic.kt"); + } + + @Test + @TestMetadata("delegation.kt") + public void testDelegation() throws Exception { + runTest("compiler/testData/diagnostics/tests/targetedBuiltIns/backwardCompatibility/delegation.kt"); + } + + @Test + @TestMetadata("derivedInterfaces.kt") + public void testDerivedInterfaces() throws Exception { + runTest("compiler/testData/diagnostics/tests/targetedBuiltIns/backwardCompatibility/derivedInterfaces.kt"); + } + + @Test + @TestMetadata("derivedInterfacesWithKotlinFun.kt") + public void testDerivedInterfacesWithKotlinFun() throws Exception { + runTest("compiler/testData/diagnostics/tests/targetedBuiltIns/backwardCompatibility/derivedInterfacesWithKotlinFun.kt"); + } + + @Test + @TestMetadata("fillInStackTrace.kt") + public void testFillInStackTrace() throws Exception { + runTest("compiler/testData/diagnostics/tests/targetedBuiltIns/backwardCompatibility/fillInStackTrace.kt"); + } + + @Test + @TestMetadata("finalize.kt") + public void testFinalize() throws Exception { + runTest("compiler/testData/diagnostics/tests/targetedBuiltIns/backwardCompatibility/finalize.kt"); + } + + @Test + @TestMetadata("hashMapGetOrDefault.kt") + public void testHashMapGetOrDefault() throws Exception { + runTest("compiler/testData/diagnostics/tests/targetedBuiltIns/backwardCompatibility/hashMapGetOrDefault.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/testWithModifiedMockJdk") + @TestDataPath("$PROJECT_ROOT") + public class TestWithModifiedMockJdk { + @Test + public void testAllFilesPresentInTestWithModifiedMockJdk() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/testWithModifiedMockJdk"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("newStringMethods.kt") + public void testNewStringMethods() throws Exception { + runTest("compiler/testData/diagnostics/tests/testWithModifiedMockJdk/newStringMethods.kt"); + } + + @Test + @TestMetadata("notConsideredMethod.kt") + public void testNotConsideredMethod() throws Exception { + runTest("compiler/testData/diagnostics/tests/testWithModifiedMockJdk/notConsideredMethod.kt"); + } + + @Test + @TestMetadata("throwableConstructor.kt") + public void testThrowableConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/testWithModifiedMockJdk/throwableConstructor.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/testsWithExplicitApi") + @TestDataPath("$PROJECT_ROOT") + public class TestsWithExplicitApi { + @Test + public void testAllFilesPresentInTestsWithExplicitApi() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/testsWithExplicitApi"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("annotations.kt") + public void testAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/annotations.kt"); + } + + @Test + @TestMetadata("classes.kt") + public void testClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/classes.kt"); + } + + @Test + @TestMetadata("companionObject.kt") + public void testCompanionObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/companionObject.kt"); + } + + @Test + @TestMetadata("constructors.kt") + public void testConstructors() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/constructors.kt"); + } + + @Test + @TestMetadata("inlineClasses.kt") + public void testInlineClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/inlineClasses.kt"); + } + + @Test + @TestMetadata("interfaces.kt") + public void testInterfaces() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/interfaces.kt"); + } + + @Test + @TestMetadata("kt56505.kt") + public void testKt56505() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/kt56505.kt"); + } + + @Test + @TestMetadata("localFunctions.kt") + public void testLocalFunctions() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/localFunctions.kt"); + } + + @Test + @TestMetadata("mustBeEffectivelyPublic.kt") + public void testMustBeEffectivelyPublic() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/mustBeEffectivelyPublic.kt"); + } + + @Test + @TestMetadata("noErrorsForMemebersInsideInternalDeclaration.kt") + public void testNoErrorsForMemebersInsideInternalDeclaration() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/noErrorsForMemebersInsideInternalDeclaration.kt"); + } + + @Test + @TestMetadata("properties.kt") + public void testProperties() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/properties.kt"); + } + + @Test + @TestMetadata("publishedApi.kt") + public void testPublishedApi() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/publishedApi.kt"); + } + + @Test + @TestMetadata("toplevel.kt") + public void testToplevel() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/toplevel.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/testsWithJava17") + @TestDataPath("$PROJECT_ROOT") + public class TestsWithJava17 { + @Test + public void testAllFilesPresentInTestsWithJava17() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/testsWithJava17"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/testsWithJava17/jvmRecord") + @TestDataPath("$PROJECT_ROOT") + public class JvmRecord { + @Test + public void testAllFilesPresentInJvmRecord() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/testsWithJava17/jvmRecord"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("diagnostics.kt") + public void testDiagnostics() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithJava17/jvmRecord/diagnostics.kt"); + } + + @Test + @TestMetadata("disabledFeature.kt") + public void testDisabledFeature() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithJava17/jvmRecord/disabledFeature.kt"); + } + + @Test + @TestMetadata("explicitSuperConstructorCall.kt") + public void testExplicitSuperConstructorCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithJava17/jvmRecord/explicitSuperConstructorCall.kt"); + } + + @Test + @TestMetadata("irrelevantFields.kt") + public void testIrrelevantFields() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithJava17/jvmRecord/irrelevantFields.kt"); + } + + @Test + @TestMetadata("javaRecordWithExplicitComponent.kt") + public void testJavaRecordWithExplicitComponent() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithJava17/jvmRecord/javaRecordWithExplicitComponent.kt"); + } + + @Test + @TestMetadata("javaRecordWithGeneric.kt") + public void testJavaRecordWithGeneric() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithJava17/jvmRecord/javaRecordWithGeneric.kt"); + } + + @Test + @TestMetadata("jvmRecordDescriptorStructure.kt") + public void testJvmRecordDescriptorStructure() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithJava17/jvmRecord/jvmRecordDescriptorStructure.kt"); + } + + @Test + @TestMetadata("simpleRecords.kt") + public void testSimpleRecords() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithJava17/jvmRecord/simpleRecords.kt"); + } + + @Test + @TestMetadata("supertypesCheck.kt") + public void testSupertypesCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithJava17/jvmRecord/supertypesCheck.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/testsWithJava17/sealedClasses") + @TestDataPath("$PROJECT_ROOT") + public class SealedClasses { + @Test + public void testAllFilesPresentInSealedClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/testsWithJava17/sealedClasses"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("flexibleSealedInSubject.kt") + public void testFlexibleSealedInSubject() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithJava17/sealedClasses/flexibleSealedInSubject.kt"); + } + + @Test + @TestMetadata("javaSealedClassExhaustiveness.kt") + public void testJavaSealedClassExhaustiveness() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithJava17/sealedClasses/javaSealedClassExhaustiveness.kt"); + } + + @Test + @TestMetadata("javaSealedInterfaceExhaustiveness.kt") + public void testJavaSealedInterfaceExhaustiveness() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithJava17/sealedClasses/javaSealedInterfaceExhaustiveness.kt"); + } + + @Test + @TestMetadata("kotlinInheritsJavaClass.kt") + public void testKotlinInheritsJavaClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithJava17/sealedClasses/kotlinInheritsJavaClass.kt"); + } + + @Test + @TestMetadata("kotlinInheritsJavaInterface.kt") + public void testKotlinInheritsJavaInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithJava17/sealedClasses/kotlinInheritsJavaInterface.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/thisAndSuper") + @TestDataPath("$PROJECT_ROOT") + public class ThisAndSuper { + @Test + public void testAllFilesPresentInThisAndSuper() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/thisAndSuper"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("ambigousLabelOnThis.kt") + public void testAmbigousLabelOnThis() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/ambigousLabelOnThis.kt"); + } + + @Test + @TestMetadata("considerAnonymousObjectsForSuperclassNotAccessibleFromInterface.kt") + public void testConsiderAnonymousObjectsForSuperclassNotAccessibleFromInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/considerAnonymousObjectsForSuperclassNotAccessibleFromInterface.kt"); + } + + @Test + @TestMetadata("genericQualifiedSuperOverridden.kt") + public void testGenericQualifiedSuperOverridden() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/genericQualifiedSuperOverridden.kt"); + } + + @Test + @TestMetadata("implicitInvokeOnSuper.kt") + public void testImplicitInvokeOnSuper() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/implicitInvokeOnSuper.kt"); + } + + @Test + @TestMetadata("notAccessibleSuperInTrait.kt") + public void testNotAccessibleSuperInTrait() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/notAccessibleSuperInTrait.kt"); + } + + @Test + @TestMetadata("qualifiedSuperOverridden.kt") + public void testQualifiedSuperOverridden() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/qualifiedSuperOverridden.kt"); + } + + @Test + @TestMetadata("QualifiedThis.kt") + public void testQualifiedThis() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/QualifiedThis.kt"); + } + + @Test + @TestMetadata("Super.kt") + public void testSuper() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/Super.kt"); + } + + @Test + @TestMetadata("superInExtensionFunction.kt") + public void testSuperInExtensionFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/superInExtensionFunction.kt"); + } + + @Test + @TestMetadata("superInExtensionFunctionCall.kt") + public void testSuperInExtensionFunctionCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/superInExtensionFunctionCall.kt"); + } + + @Test + @TestMetadata("superInToplevelFunction.kt") + public void testSuperInToplevelFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/superInToplevelFunction.kt"); + } + + @Test + @TestMetadata("superIsNotAnExpression.kt") + public void testSuperIsNotAnExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/superIsNotAnExpression.kt"); + } + + @Test + @TestMetadata("thisInFunctionLiterals.kt") + public void testThisInFunctionLiterals() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/thisInFunctionLiterals.kt"); + } + + @Test + @TestMetadata("thisInInnerClasses.kt") + public void testThisInInnerClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/thisInInnerClasses.kt"); + } + + @Test + @TestMetadata("thisInPropertyInitializer.kt") + public void testThisInPropertyInitializer() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/thisInPropertyInitializer.kt"); + } + + @Test + @TestMetadata("thisInToplevelFunction.kt") + public void testThisInToplevelFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/thisInToplevelFunction.kt"); + } + + @Test + @TestMetadata("traitSuperCall.kt") + public void testTraitSuperCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/traitSuperCall.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper") + @TestDataPath("$PROJECT_ROOT") + public class UnqualifiedSuper { + @Test + public void testAllFilesPresentInUnqualifiedSuper() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("ambiguousSuperWithGenerics.kt") + public void testAmbiguousSuperWithGenerics() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/ambiguousSuperWithGenerics.kt"); + } + + @Test + @TestMetadata("unqualifiedSuper.kt") + public void testUnqualifiedSuper() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuper.kt"); + } + + @Test + @TestMetadata("unqualifiedSuperWithAbstractMembers.kt") + public void testUnqualifiedSuperWithAbstractMembers() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithAbstractMembers.kt"); + } + + @Test + @TestMetadata("unqualifiedSuperWithCallableProperty.kt") + public void testUnqualifiedSuperWithCallableProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithCallableProperty.kt"); + } + + @Test + @TestMetadata("unqualifiedSuperWithDeeperHierarchies.kt") + public void testUnqualifiedSuperWithDeeperHierarchies() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithDeeperHierarchies.kt"); + } + + @Test + @TestMetadata("unqualifiedSuperWithGenerics.kt") + public void testUnqualifiedSuperWithGenerics() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithGenerics.kt"); + } + + @Test + @TestMetadata("unqualifiedSuperWithInnerClass.kt") + public void testUnqualifiedSuperWithInnerClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithInnerClass.kt"); + } + + @Test + @TestMetadata("unqualifiedSuperWithInterfaces.kt") + public void testUnqualifiedSuperWithInterfaces() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithInterfaces.kt"); + } + + @Test + @TestMetadata("unqualifiedSuperWithLocalClass.kt") + public void testUnqualifiedSuperWithLocalClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithLocalClass.kt"); + } + + @Test + @TestMetadata("unqualifiedSuperWithUnresolvedBase.kt") + public void testUnqualifiedSuperWithUnresolvedBase() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithUnresolvedBase.kt"); + } + + @Test + @TestMetadata("withMethodOfAnyOverridenInInterface.kt") + public void testWithMethodOfAnyOverridenInInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/withMethodOfAnyOverridenInInterface.kt"); + } + + @Test + @TestMetadata("withMethodOverriddenInAnotherSupertype.kt") + public void testWithMethodOverriddenInAnotherSupertype() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/withMethodOverriddenInAnotherSupertype.kt"); + } + + @Test + @TestMetadata("withMethodsOfAny.kt") + public void testWithMethodsOfAny() throws Exception { + runTest("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/withMethodsOfAny.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/traitWithRequired") + @TestDataPath("$PROJECT_ROOT") + public class TraitWithRequired { + @Test + public void testAllFilesPresentInTraitWithRequired() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/traitWithRequired"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("traitRequiresAny.kt") + public void testTraitRequiresAny() throws Exception { + runTest("compiler/testData/diagnostics/tests/traitWithRequired/traitRequiresAny.kt"); + } + + @Test + @TestMetadata("traitSupertypeList.kt") + public void testTraitSupertypeList() throws Exception { + runTest("compiler/testData/diagnostics/tests/traitWithRequired/traitSupertypeList.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/typeParameters") + @TestDataPath("$PROJECT_ROOT") + public class TypeParameters { + @Test + public void testAllFilesPresentInTypeParameters() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/typeParameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("cannotHaveManyClassUpperBounds.kt") + public void testCannotHaveManyClassUpperBounds() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/cannotHaveManyClassUpperBounds.kt"); + } + + @Test + @TestMetadata("deprecatedSyntax.kt") + public void testDeprecatedSyntax() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/deprecatedSyntax.kt"); + } + + @Test + @TestMetadata("destructuringDeclarations.kt") + public void testDestructuringDeclarations() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/destructuringDeclarations.kt"); + } + + @Test + @TestMetadata("dontIntersectUpperBoundWithExpectedType.kt") + public void testDontIntersectUpperBoundWithExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/dontIntersectUpperBoundWithExpectedType.kt"); + } + + @Test + @TestMetadata("dontLoseUpperNonExpectedTypeConstraints.kt") + public void testDontLoseUpperNonExpectedTypeConstraints() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/dontLoseUpperNonExpectedTypeConstraints.kt"); + } + + @Test + @TestMetadata("extFunctionTypeAsUpperBound.kt") + public void testExtFunctionTypeAsUpperBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/extFunctionTypeAsUpperBound.kt"); + } + + @Test + @TestMetadata("functionTypeAsUpperBound.kt") + public void testFunctionTypeAsUpperBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/functionTypeAsUpperBound.kt"); + } + + @Test + @TestMetadata("implicitNothingAgainstNotNothingExpectedType.kt") + public void testImplicitNothingAgainstNotNothingExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/implicitNothingAgainstNotNothingExpectedType.kt"); + } + + @Test + @TestMetadata("implicitNothingInReturnPosition.kt") + public void testImplicitNothingInReturnPosition() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/implicitNothingInReturnPosition.kt"); + } + + @Test + @TestMetadata("implicitNothingOfJavaCallAgainstNotNothingExpectedType.kt") + public void testImplicitNothingOfJavaCallAgainstNotNothingExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/implicitNothingOfJavaCallAgainstNotNothingExpectedType.kt"); + } + + @Test + @TestMetadata("implicitNothingOnDelegates.kt") + public void testImplicitNothingOnDelegates() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/implicitNothingOnDelegates.kt"); + } + + @Test + @TestMetadata("inProjectedDnnParameter.kt") + public void testInProjectedDnnParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/inProjectedDnnParameter.kt"); + } + + @Test + @TestMetadata("kt42042.kt") + public void testKt42042() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/kt42042.kt"); + } + + @Test + @TestMetadata("kt42042Error.kt") + public void testKt42042Error() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/kt42042Error.kt"); + } + + @Test + @TestMetadata("kt42396.kt") + public void testKt42396() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/kt42396.kt"); + } + + @Test + @TestMetadata("kt42472.kt") + public void testKt42472() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/kt42472.kt"); + } + + @Test + @TestMetadata("kt46186.kt") + public void testKt46186() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/kt46186.kt"); + } + + @Test + @TestMetadata("kt46186withEmptyIntersections.kt") + public void testKt46186withEmptyIntersections() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/kt46186withEmptyIntersections.kt"); + } + + @Test + @TestMetadata("misplacedConstraints.kt") + public void testMisplacedConstraints() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/misplacedConstraints.kt"); + } + + @Test + @TestMetadata("propertyTypeParameters.kt") + public void testPropertyTypeParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/propertyTypeParameters.kt"); + } + + @Test + @TestMetadata("propertyTypeParametersWithUpperBounds.kt") + public void testPropertyTypeParametersWithUpperBounds() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/propertyTypeParametersWithUpperBounds.kt"); + } + + @Test + @TestMetadata("repeatedBound.kt") + public void testRepeatedBound() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/repeatedBound.kt"); + } + + @Test + @TestMetadata("starProjectionInsteadOutCaptured.kt") + public void testStarProjectionInsteadOutCaptured() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/starProjectionInsteadOutCaptured.kt"); + } + + @Test + @TestMetadata("typeMismatchErrorHasExpectedGenericTypeArgumentInsteadOfTypeParameter.kt") + public void testTypeMismatchErrorHasExpectedGenericTypeArgumentInsteadOfTypeParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/typeMismatchErrorHasExpectedGenericTypeArgumentInsteadOfTypeParameter.kt"); + } + + @Test + @TestMetadata("typeParameterChainInReceiver.kt") + public void testTypeParameterChainInReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/typeParameterChainInReceiver.kt"); + } + + @Test + @TestMetadata("typeParameterChainInReturnType.kt") + public void testTypeParameterChainInReturnType() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/typeParameterChainInReturnType.kt"); + } + + @Test + @TestMetadata("upperBoundCannotBeArray.kt") + public void testUpperBoundCannotBeArray() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeParameters/upperBoundCannotBeArray.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/typealias") + @TestDataPath("$PROJECT_ROOT") + public class Typealias { + @Test + @TestMetadata("abbreviatedSupertypes.kt") + public void testAbbreviatedSupertypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/abbreviatedSupertypes.kt"); + } + + @Test + @TestMetadata("abbreviatedSupertypesErrors.kt") + public void testAbbreviatedSupertypesErrors() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/abbreviatedSupertypesErrors.kt"); + } + + @Test + @TestMetadata("aliasesOnly.kt") + public void testAliasesOnly() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/aliasesOnly.kt"); + } + + @Test + public void testAllFilesPresentInTypealias() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/typealias"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("annotationsOnTypeAliases.kt") + public void testAnnotationsOnTypeAliases() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/annotationsOnTypeAliases.kt"); + } + + @Test + @TestMetadata("boundViolationInTypeAliasConstructor.kt") + public void testBoundViolationInTypeAliasConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/boundViolationInTypeAliasConstructor.kt"); + } + + @Test + @TestMetadata("boundsViolationInDeepTypeAliasExpansion.kt") + public void testBoundsViolationInDeepTypeAliasExpansion() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/boundsViolationInDeepTypeAliasExpansion.kt"); + } + + @Test + @TestMetadata("boundsViolationInTypeAliasExpansion.kt") + public void testBoundsViolationInTypeAliasExpansion() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/boundsViolationInTypeAliasExpansion.kt"); + } + + @Test + @TestMetadata("boundsViolationInTypeAliasRHS.kt") + public void testBoundsViolationInTypeAliasRHS() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/boundsViolationInTypeAliasRHS.kt"); + } + + @Test + @TestMetadata("boundsViolationRecursive.kt") + public void testBoundsViolationRecursive() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/boundsViolationRecursive.kt"); + } + + @Test + @TestMetadata("capturingTypeParametersFromOuterClass.kt") + public void testCapturingTypeParametersFromOuterClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/capturingTypeParametersFromOuterClass.kt"); + } + + @Test + @TestMetadata("classReference.kt") + public void testClassReference() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/classReference.kt"); + } + + @Test + @TestMetadata("conflictingProjections.kt") + public void testConflictingProjections() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/conflictingProjections.kt"); + } + + @Test + @TestMetadata("constructorCallThroughPrivateAlias.kt") + public void testConstructorCallThroughPrivateAlias() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/constructorCallThroughPrivateAlias.kt"); + } + + @Test + @TestMetadata("cyclicInheritanceViaTypeAlias.kt") + public void testCyclicInheritanceViaTypeAlias() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/cyclicInheritanceViaTypeAlias.kt"); + } + + @Test + @TestMetadata("enumEntryQualifier.kt") + public void testEnumEntryQualifier() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/enumEntryQualifier.kt"); + } + + @Test + @TestMetadata("exposedExpandedType.kt") + public void testExposedExpandedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/exposedExpandedType.kt"); + } + + @Test + @TestMetadata("functionTypeInTypeAlias.kt") + public void testFunctionTypeInTypeAlias() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/functionTypeInTypeAlias.kt"); + } + + @Test + @TestMetadata("functionalTypeWithParameterNameVisibility.kt") + public void testFunctionalTypeWithParameterNameVisibility() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/functionalTypeWithParameterNameVisibility.kt"); + } + + @Test + @TestMetadata("genericTypeAliasConstructor.kt") + public void testGenericTypeAliasConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/genericTypeAliasConstructor.kt"); + } + + @Test + @TestMetadata("genericTypeAliasObject.kt") + public void testGenericTypeAliasObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/genericTypeAliasObject.kt"); + } + + @Test + @TestMetadata("illegalTypeInTypeAliasExpansion.kt") + public void testIllegalTypeInTypeAliasExpansion() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/illegalTypeInTypeAliasExpansion.kt"); + } + + @Test + @TestMetadata("import.kt") + public void testImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/import.kt"); + } + + @Test + @TestMetadata("importForTypealiasObject.kt") + public void testImportForTypealiasObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/importForTypealiasObject.kt"); + } + + @Test + @TestMetadata("importFromTypeAliasObject.kt") + public void testImportFromTypeAliasObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/importFromTypeAliasObject.kt"); + } + + @Test + @TestMetadata("importMemberFromJavaViaAlias.kt") + public void testImportMemberFromJavaViaAlias() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/importMemberFromJavaViaAlias.kt"); + } + + @Test + @TestMetadata("inGenerics.kt") + public void testInGenerics() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/inGenerics.kt"); + } + + @Test + @TestMetadata("inSupertypesList.kt") + public void testInSupertypesList() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/inSupertypesList.kt"); + } + + @Test + @TestMetadata("inheritedNestedTypeAlias.kt") + public void testInheritedNestedTypeAlias() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/inheritedNestedTypeAlias.kt"); + } + + @Test + @TestMetadata("inhreritedTypeAliasQualifiedByDerivedClass.kt") + public void testInhreritedTypeAliasQualifiedByDerivedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/inhreritedTypeAliasQualifiedByDerivedClass.kt"); + } + + @Test + @TestMetadata("innerClassTypeAliasConstructor.kt") + public void testInnerClassTypeAliasConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/innerClassTypeAliasConstructor.kt"); + } + + @Test + @TestMetadata("innerClassTypeAliasConstructorInSupertypes.kt") + public void testInnerClassTypeAliasConstructorInSupertypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/innerClassTypeAliasConstructorInSupertypes.kt"); + } + + @Test + @TestMetadata("innerTypeAliasAsType.kt") + public void testInnerTypeAliasAsType() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/innerTypeAliasAsType.kt"); + } + + @Test + @TestMetadata("innerTypeAliasAsType2.kt") + public void testInnerTypeAliasAsType2() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/innerTypeAliasAsType2.kt"); + } + + @Test + @TestMetadata("innerTypeAliasConstructor.kt") + public void testInnerTypeAliasConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/innerTypeAliasConstructor.kt"); + } + + @Test + @TestMetadata("intToLongApproximationThroughTypeAlias.kt") + public void testIntToLongApproximationThroughTypeAlias() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/intToLongApproximationThroughTypeAlias.kt"); + } + + @Test + @TestMetadata("isAsWithTypeAlias.kt") + public void testIsAsWithTypeAlias() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/isAsWithTypeAlias.kt"); + } + + @Test + @TestMetadata("javaStaticMembersViaTypeAlias.kt") + public void testJavaStaticMembersViaTypeAlias() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/javaStaticMembersViaTypeAlias.kt"); + } + + @Test + @TestMetadata("kt14498.kt") + public void testKt14498() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/kt14498.kt"); + } + + @Test + @TestMetadata("kt14498a.kt") + public void testKt14498a() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/kt14498a.kt"); + } + + @Test + @TestMetadata("kt14518.kt") + public void testKt14518() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/kt14518.kt"); + } + + @Test + @TestMetadata("kt14612.kt") + public void testKt14612() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/kt14612.kt"); + } + + @Test + @TestMetadata("kt14641.kt") + public void testKt14641() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/kt14641.kt"); + } + + @Test + @TestMetadata("kt15734.kt") + public void testKt15734() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/kt15734.kt"); + } + + @Test + @TestMetadata("kt19601.kt") + public void testKt19601() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/kt19601.kt"); + } + + @Test + @TestMetadata("kt57065.kt") + public void testKt57065() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/kt57065.kt"); + } + + @Test + @TestMetadata("localTypeAlias.kt") + public void testLocalTypeAlias() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/localTypeAlias.kt"); + } + + @Test + @TestMetadata("localTypeAliasConstructor.kt") + public void testLocalTypeAliasConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/localTypeAliasConstructor.kt"); + } + + @Test + @TestMetadata("localTypeAliasModifiers.kt") + public void testLocalTypeAliasModifiers() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/localTypeAliasModifiers.kt"); + } + + @Test + @TestMetadata("localTypeAliasRecursive.kt") + public void testLocalTypeAliasRecursive() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/localTypeAliasRecursive.kt"); + } + + @Test + @TestMetadata("methodReference.kt") + public void testMethodReference() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/methodReference.kt"); + } + + @Test + @TestMetadata("nested.kt") + public void testNested() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/nested.kt"); + } + + @Test + @TestMetadata("nestedCapturingTypeParameters.kt") + public void testNestedCapturingTypeParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/nestedCapturingTypeParameters.kt"); + } + + @Test + @TestMetadata("nestedSubstituted.kt") + public void testNestedSubstituted() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/nestedSubstituted.kt"); + } + + @Test + @TestMetadata("noApproximationInTypeAliasArgumentSubstitution.kt") + public void testNoApproximationInTypeAliasArgumentSubstitution() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/noApproximationInTypeAliasArgumentSubstitution.kt"); + } + + @Test + @TestMetadata("noRHS.kt") + public void testNoRHS() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/noRHS.kt"); + } + + @Test + @TestMetadata("parameterRestrictions.kt") + public void testParameterRestrictions() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/parameterRestrictions.kt"); + } + + @Test + @TestMetadata("parameterSubstitution.kt") + public void testParameterSubstitution() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/parameterSubstitution.kt"); + } + + @Test + @TestMetadata("privateInFile.kt") + public void testPrivateInFile() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/privateInFile.kt"); + } + + @Test + @TestMetadata("projectionsInTypeAliasConstructor.kt") + public void testProjectionsInTypeAliasConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/projectionsInTypeAliasConstructor.kt"); + } + + @Test + @TestMetadata("recursive.kt") + public void testRecursive() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/recursive.kt"); + } + + @Test + @TestMetadata("returnTypeNothingShouldBeSpecifiedExplicitly.kt") + public void testReturnTypeNothingShouldBeSpecifiedExplicitly() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/returnTypeNothingShouldBeSpecifiedExplicitly.kt"); + } + + @Test + @TestMetadata("simpleTypeAlias.kt") + public void testSimpleTypeAlias() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/simpleTypeAlias.kt"); + } + + @Test + @TestMetadata("starImportOnTypeAlias.kt") + public void testStarImportOnTypeAlias() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/starImportOnTypeAlias.kt"); + } + + @Test + @TestMetadata("starProjection.kt") + public void testStarProjection() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/starProjection.kt"); + } + + @Test + @TestMetadata("starProjectionInTypeAliasArgument.kt") + public void testStarProjectionInTypeAliasArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/starProjectionInTypeAliasArgument.kt"); + } + + @Test + @TestMetadata("substitutionVariance.kt") + public void testSubstitutionVariance() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/substitutionVariance.kt"); + } + + @Test + @TestMetadata("throwJLException.kt") + public void testThrowJLException() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/throwJLException.kt"); + } + + @Test + @TestMetadata("topLevelTypeAliasesOnly.kt") + public void testTopLevelTypeAliasesOnly() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/topLevelTypeAliasesOnly.kt"); + } + + @Test + @TestMetadata("typeAliasArgumentsInCompanionObject.kt") + public void testTypeAliasArgumentsInCompanionObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasArgumentsInCompanionObject.kt"); + } + + @Test + @TestMetadata("typeAliasArgumentsInConstructor.kt") + public void testTypeAliasArgumentsInConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasArgumentsInConstructor.kt"); + } + + @Test + @TestMetadata("typeAliasAsBareType.kt") + public void testTypeAliasAsBareType() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasAsBareType.kt"); + } + + @Test + @TestMetadata("typeAliasAsQualifier.kt") + public void testTypeAliasAsQualifier() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasAsQualifier.kt"); + } + + @Test + @TestMetadata("typeAliasAsSuperQualifier.kt") + public void testTypeAliasAsSuperQualifier() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasAsSuperQualifier.kt"); + } + + @Test + @TestMetadata("typeAliasConstructor.kt") + public void testTypeAliasConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructor.kt"); + } + + @Test + @TestMetadata("typeAliasConstructorCrazyProjections.kt") + public void testTypeAliasConstructorCrazyProjections() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorCrazyProjections.kt"); + } + + @Test + @TestMetadata("typeAliasConstructorForInterface.kt") + public void testTypeAliasConstructorForInterface() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorForInterface.kt"); + } + + @Test + @TestMetadata("typeAliasConstructorForProjection.kt") + public void testTypeAliasConstructorForProjection() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorForProjection.kt"); + } + + @Test + @TestMetadata("typeAliasConstructorForProjectionInSupertypes.kt") + public void testTypeAliasConstructorForProjectionInSupertypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorForProjectionInSupertypes.kt"); + } + + @Test + @TestMetadata("typeAliasConstructorInSuperCall.kt") + public void testTypeAliasConstructorInSuperCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorInSuperCall.kt"); + } + + @Test + @TestMetadata("typeAliasConstructorInferenceInSupertypesList.kt") + public void testTypeAliasConstructorInferenceInSupertypesList() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorInferenceInSupertypesList.kt"); + } + + @Test + @TestMetadata("typeAliasConstructorReturnType.kt") + public void testTypeAliasConstructorReturnType() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorReturnType.kt"); + } + + @Test + @TestMetadata("typeAliasConstructorTypeArgumentsInference.kt") + public void testTypeAliasConstructorTypeArgumentsInference() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInference.kt"); + } + + @Test + @TestMetadata("typeAliasConstructorTypeArgumentsInferenceWithNestedCalls.kt") + public void testTypeAliasConstructorTypeArgumentsInferenceWithNestedCalls() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls.kt"); + } + + @Test + @TestMetadata("typeAliasConstructorTypeArgumentsInferenceWithNestedCalls2.kt") + public void testTypeAliasConstructorTypeArgumentsInferenceWithNestedCalls2() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls2.kt"); + } + + @Test + @TestMetadata("typeAliasConstructorTypeArgumentsInferenceWithPhantomTypes.kt") + public void testTypeAliasConstructorTypeArgumentsInferenceWithPhantomTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithPhantomTypes.kt"); + } + + @Test + @TestMetadata("typeAliasConstructorVsFunction.kt") + public void testTypeAliasConstructorVsFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorVsFunction.kt"); + } + + @Test + @TestMetadata("typeAliasConstructorWrongClass.kt") + public void testTypeAliasConstructorWrongClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorWrongClass.kt"); + } + + @Test + @TestMetadata("typeAliasConstructorWrongVisibility.kt") + public void testTypeAliasConstructorWrongVisibility() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorWrongVisibility.kt"); + } + + @Test + @TestMetadata("typeAliasExpansionRepeatedAnnotations.kt") + public void testTypeAliasExpansionRepeatedAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasExpansionRepeatedAnnotations.kt"); + } + + @Test + @TestMetadata("typeAliasForProjectionInSuperInterfaces.kt") + public void testTypeAliasForProjectionInSuperInterfaces() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasForProjectionInSuperInterfaces.kt"); + } + + @Test + @TestMetadata("typeAliasInAnonymousObjectType.kt") + public void testTypeAliasInAnonymousObjectType() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasInAnonymousObjectType.kt"); + } + + @Test + @TestMetadata("typeAliasInvisibleObject.kt") + public void testTypeAliasInvisibleObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasInvisibleObject.kt"); + } + + @Test + @TestMetadata("typeAliasIsUsedAsATypeArgumentInOtherAlias.kt") + public void testTypeAliasIsUsedAsATypeArgumentInOtherAlias() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasIsUsedAsATypeArgumentInOtherAlias.kt"); + } + + @Test + @TestMetadata("typeAliasNotNull.kt") + public void testTypeAliasNotNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasNotNull.kt"); + } + + @Test + @TestMetadata("typeAliasObject.kt") + public void testTypeAliasObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasObject.kt"); + } + + @Test + @TestMetadata("typeAliasObjectWithInvoke.kt") + public void testTypeAliasObjectWithInvoke() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasObjectWithInvoke.kt"); + } + + @Test + @TestMetadata("typeAliasShouldExpandToClass.kt") + public void testTypeAliasShouldExpandToClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasShouldExpandToClass.kt"); + } + + @Test + @TestMetadata("typeAliasesInImportDirectives.kt") + public void testTypeAliasesInImportDirectives() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasesInImportDirectives.kt"); + } + + @Test + @TestMetadata("typeAliasesInQualifiers.kt") + public void testTypeAliasesInQualifiers() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typeAliasesInQualifiers.kt"); + } + + @Test + @TestMetadata("typealiasRhsAnnotations.kt") + public void testTypealiasRhsAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typealiasRhsAnnotations.kt"); + } + + @Test + @TestMetadata("typealiasRhsAnnotationsInArguments.kt") + public void testTypealiasRhsAnnotationsInArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typealiasRhsAnnotationsInArguments.kt"); + } + + @Test + @TestMetadata("typealiasRhsRepeatedAnnotationInArguments.kt") + public void testTypealiasRhsRepeatedAnnotationInArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typealiasRhsRepeatedAnnotationInArguments.kt"); + } + + @Test + @TestMetadata("typealiasRhsRepeatedAnnotations.kt") + public void testTypealiasRhsRepeatedAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/typealiasRhsRepeatedAnnotations.kt"); + } + + @Test + @TestMetadata("unusedTypeAliasParameter.kt") + public void testUnusedTypeAliasParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/unusedTypeAliasParameter.kt"); + } + + @Test + @TestMetadata("wrongNumberOfArgumentsInTypeAliasConstructor.kt") + public void testWrongNumberOfArgumentsInTypeAliasConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/typealias/wrongNumberOfArgumentsInTypeAliasConstructor.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/underscoresInNumericLiterals") + @TestDataPath("$PROJECT_ROOT") + public class UnderscoresInNumericLiterals { + @Test + public void testAllFilesPresentInUnderscoresInNumericLiterals() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/underscoresInNumericLiterals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("illegalUnderscores.kt") + public void testIllegalUnderscores() throws Exception { + runTest("compiler/testData/diagnostics/tests/underscoresInNumericLiterals/illegalUnderscores.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/unit") + @TestDataPath("$PROJECT_ROOT") + public class Unit { + @Test + public void testAllFilesPresentInUnit() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("nullableUnit.kt") + public void testNullableUnit() throws Exception { + runTest("compiler/testData/diagnostics/tests/unit/nullableUnit.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/unitConversion") + @TestDataPath("$PROJECT_ROOT") + public class UnitConversion { + @Test + public void testAllFilesPresentInUnitConversion() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unitConversion"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("chainedFunSuspendUnitConversion.kt") + public void testChainedFunSuspendUnitConversion() throws Exception { + runTest("compiler/testData/diagnostics/tests/unitConversion/chainedFunSuspendUnitConversion.kt"); + } + + @Test + @TestMetadata("chainedFunUnitConversion.kt") + public void testChainedFunUnitConversion() throws Exception { + runTest("compiler/testData/diagnostics/tests/unitConversion/chainedFunUnitConversion.kt"); + } + + @Test + @TestMetadata("chainedUnitSuspendConversion.kt") + public void testChainedUnitSuspendConversion() throws Exception { + runTest("compiler/testData/diagnostics/tests/unitConversion/chainedUnitSuspendConversion.kt"); + } + + @Test + @TestMetadata("kt49394.kt") + public void testKt49394() throws Exception { + runTest("compiler/testData/diagnostics/tests/unitConversion/kt49394.kt"); + } + + @Test + @TestMetadata("noUnitConversionForGenericTypeFromArrow.kt") + public void testNoUnitConversionForGenericTypeFromArrow() throws Exception { + runTest("compiler/testData/diagnostics/tests/unitConversion/noUnitConversionForGenericTypeFromArrow.kt"); + } + + @Test + @TestMetadata("noUnitConversionOnReturningGenericFunctionalType.kt") + public void testNoUnitConversionOnReturningGenericFunctionalType() throws Exception { + runTest("compiler/testData/diagnostics/tests/unitConversion/noUnitConversionOnReturningGenericFunctionalType.kt"); + } + + @Test + @TestMetadata("unitConversionCompatibility.kt") + public void testUnitConversionCompatibility() throws Exception { + runTest("compiler/testData/diagnostics/tests/unitConversion/unitConversionCompatibility.kt"); + } + + @Test + @TestMetadata("unitConversionDisabledForSimpleArguments.kt") + public void testUnitConversionDisabledForSimpleArguments() throws Exception { + runTest("compiler/testData/diagnostics/tests/unitConversion/unitConversionDisabledForSimpleArguments.kt"); + } + + @Test + @TestMetadata("unitConversionForAllKinds.kt") + public void testUnitConversionForAllKinds() throws Exception { + runTest("compiler/testData/diagnostics/tests/unitConversion/unitConversionForAllKinds.kt"); + } + + @Test + @TestMetadata("unitConversionForSubtypes.kt") + public void testUnitConversionForSubtypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/unitConversion/unitConversionForSubtypes.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/unsignedTypes") + @TestDataPath("$PROJECT_ROOT") + public class UnsignedTypes { + @Test + public void testAllFilesPresentInUnsignedTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unsignedTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("allowedVarargsOfUnsignedTypes.kt") + public void testAllowedVarargsOfUnsignedTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/allowedVarargsOfUnsignedTypes.kt"); + } + + @Test + @TestMetadata("callDefaultConstructorOfUnsignedType.kt") + public void testCallDefaultConstructorOfUnsignedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/callDefaultConstructorOfUnsignedType.kt"); + } + + @Test + @TestMetadata("explicitUnsignedLongTypeCheck.kt") + public void testExplicitUnsignedLongTypeCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/explicitUnsignedLongTypeCheck.kt"); + } + + @Test + @TestMetadata("forbiddenEqualsOnUnsignedTypes.kt") + public void testForbiddenEqualsOnUnsignedTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/forbiddenEqualsOnUnsignedTypes.kt"); + } + + @Test + @TestMetadata("lateinitUnsignedType.kt") + public void testLateinitUnsignedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/lateinitUnsignedType.kt"); + } + + @Test + @TestMetadata("overloadResolutionOfBasicOperations.kt") + public void testOverloadResolutionOfBasicOperations() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/overloadResolutionOfBasicOperations.kt"); + } + + @Test + @TestMetadata("unsignedLiteralsInsideConstVals.kt") + public void testUnsignedLiteralsInsideConstVals() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsInsideConstVals.kt"); + } + + @Test + @TestMetadata("unsignedLiteralsOverflowSignedBorder.kt") + public void testUnsignedLiteralsOverflowSignedBorder() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOverflowSignedBorder.kt"); + } + + @Test + @TestMetadata("unsignedLiteralsTypeCheck.kt") + public void testUnsignedLiteralsTypeCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsTypeCheck.kt"); + } + + @Test + @TestMetadata("varargTypeToArrayTypeCheck.kt") + public void testVarargTypeToArrayTypeCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/varargTypeToArrayTypeCheck.kt"); + } + + @Test + @TestMetadata("wrongLongSuffixForULong.kt") + public void testWrongLongSuffixForULong() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/wrongLongSuffixForULong.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/unsignedTypes/conversions") + @TestDataPath("$PROJECT_ROOT") + public class Conversions { + @Test + public void testAllFilesPresentInConversions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unsignedTypes/conversions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("conversionOfSignedToUnsigned.kt") + public void testConversionOfSignedToUnsigned() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/conversions/conversionOfSignedToUnsigned.kt"); + } + + @Test + @TestMetadata("inferenceForSignedAndUnsignedTypes.kt") + public void testInferenceForSignedAndUnsignedTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/conversions/inferenceForSignedAndUnsignedTypes.kt"); + } + + @Test + @TestMetadata("noConversionForUnsignedTypesOnReceiver.kt") + public void testNoConversionForUnsignedTypesOnReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/conversions/noConversionForUnsignedTypesOnReceiver.kt"); + } + + @Test + @TestMetadata("overloadResolutionForSignedAndUnsignedTypes.kt") + public void testOverloadResolutionForSignedAndUnsignedTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/conversions/overloadResolutionForSignedAndUnsignedTypes.kt"); + } + + @Test + @TestMetadata("signedToUnsignedConversionWithExpectedType.kt") + public void testSignedToUnsignedConversionWithExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/valueClasses") + @TestDataPath("$PROJECT_ROOT") + public class ValueClasses { + @Test + public void testAllFilesPresentInValueClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/valueClasses"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("annotations.kt") + public void testAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/annotations.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithUniversal()); + } + + @Test + @TestMetadata("basicValueClassDeclaration.kt") + public void testBasicValueClassDeclaration() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclaration.kt"); + } + + @Test + @TestMetadata("basicValueClassDeclarationDisabled.kt") + public void testBasicValueClassDeclarationDisabled() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclarationDisabled.kt"); + } + + @Test + @TestMetadata("constructorsJvmSignaturesClash.kt") + public void testConstructorsJvmSignaturesClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/constructorsJvmSignaturesClash.kt"); + } + + @Test + @TestMetadata("defaultParameters.kt") + public void testDefaultParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/defaultParameters.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithUniversal()); + } + + @Test + @TestMetadata("delegatedPropertyInValueClass.kt") + public void testDelegatedPropertyInValueClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/delegatedPropertyInValueClass.kt"); + } + + @Test + @TestMetadata("functionsJvmSignaturesClash.kt") + public void testFunctionsJvmSignaturesClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesClash.kt"); + } + + @Test + @TestMetadata("functionsJvmSignaturesConflictOnInheritance.kt") + public void testFunctionsJvmSignaturesConflictOnInheritance() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesConflictOnInheritance.kt"); + } + + @Test + @TestMetadata("identityComparisonWithValueClasses.kt") + public void testIdentityComparisonWithValueClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/identityComparisonWithValueClasses.kt"); + } + + @Test + @TestMetadata("inefficientEqualsOverridingInMfvc.kt") + public void testInefficientEqualsOverridingInMfvc() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/inefficientEqualsOverridingInMfvc.kt"); + } + + @Test + @TestMetadata("inlineKeywordForMfvc.kt") + public void testInlineKeywordForMfvc() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/inlineKeywordForMfvc.kt"); + } + + @Test + @TestMetadata("jvmInlineApplicability.kt") + public void testJvmInlineApplicability() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/jvmInlineApplicability.kt"); + } + + @Test + @TestMetadata("lateinitValueClasses.kt") + public void testLateinitValueClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/lateinitValueClasses.kt"); + } + + @Test + @TestMetadata("presenceOfInitializerBlockInsideValueClass.kt") + public void testPresenceOfInitializerBlockInsideValueClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/presenceOfInitializerBlockInsideValueClass.kt"); + } + + @Test + @TestMetadata("presenceOfPublicPrimaryConstructorForValueClass.kt") + public void testPresenceOfPublicPrimaryConstructorForValueClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/presenceOfPublicPrimaryConstructorForValueClass.kt"); + } + + @Test + @TestMetadata("propertiesWithBackingFieldsInsideValueClass.kt") + public void testPropertiesWithBackingFieldsInsideValueClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/propertiesWithBackingFieldsInsideValueClass.kt"); + } + + @Test + @TestMetadata("recursiveMultiFieldValueClasses.kt") + public void testRecursiveMultiFieldValueClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/recursiveMultiFieldValueClasses.kt"); + } + + @Test + @TestMetadata("recursiveValueClasses.kt") + public void testRecursiveValueClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/recursiveValueClasses.kt"); + } + + @Test + @TestMetadata("reservedMembersAndConstructsInsideMfvc.kt") + public void testReservedMembersAndConstructsInsideMfvc() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/reservedMembersAndConstructsInsideMfvc.kt"); + } + + @Test + @TestMetadata("typedEqualsOperatorModifierInMfvc.kt") + public void testTypedEqualsOperatorModifierInMfvc() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/typedEqualsOperatorModifierInMfvc.kt"); + } + + @Test + @TestMetadata("unsignedLiteralsWithoutArtifactOnClasspath.kt") + public void testUnsignedLiteralsWithoutArtifactOnClasspath() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/unsignedLiteralsWithoutArtifactOnClasspath.kt"); + } + + @Test + @TestMetadata("valueClassCanOnlyImplementInterfaces.kt") + public void testValueClassCanOnlyImplementInterfaces() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassCanOnlyImplementInterfaces.kt"); + } + + @Test + @TestMetadata("valueClassCannotImplementInterfaceByDelegation.kt") + public void testValueClassCannotImplementInterfaceByDelegation() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassCannotImplementInterfaceByDelegation.kt"); + } + + @Test + @TestMetadata("valueClassConstructorParameterWithDefaultValue.kt") + public void testValueClassConstructorParameterWithDefaultValue() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassConstructorParameterWithDefaultValue.kt"); + } + + @Test + @TestMetadata("valueClassDeclarationCheck.kt") + public void testValueClassDeclarationCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassDeclarationCheck.kt"); + } + + @Test + @TestMetadata("valueClassImplementsCollection.kt") + public void testValueClassImplementsCollection() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassImplementsCollection.kt"); + } + + @Test + @TestMetadata("valueClassWithForbiddenUnderlyingType.kt") + public void testValueClassWithForbiddenUnderlyingType() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingType.kt"); + } + + @Test + @TestMetadata("valueClassWithForbiddenUnderlyingTypeMultiField.kt") + public void testValueClassWithForbiddenUnderlyingTypeMultiField() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingTypeMultiField.kt"); + } + + @Test + @TestMetadata("valueClassWithGenericUnderlyingTypeNoFeature.kt") + public void testValueClassWithGenericUnderlyingTypeNoFeature() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassWithGenericUnderlyingTypeNoFeature.kt"); + } + + @Test + @TestMetadata("valueClassesInsideAnnotations.kt") + public void testValueClassesInsideAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassesInsideAnnotations.kt"); + } + + @Test + @TestMetadata("varargsOnParametersOfValueClassType.kt") + public void testVarargsOnParametersOfValueClassType() throws Exception { + runTest("compiler/testData/diagnostics/tests/valueClasses/varargsOnParametersOfValueClassType.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/varargs") + @TestDataPath("$PROJECT_ROOT") + public class Varargs { + @Test + public void testAllFilesPresentInVarargs() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/varargs"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("AmbiguousVararg.kt") + public void testAmbiguousVararg() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/AmbiguousVararg.kt"); + } + + @Test + @TestMetadata("assignArrayToVararagInNamedFormWithInference.kt") + public void testAssignArrayToVararagInNamedFormWithInference() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedFormWithInference.kt"); + } + + @Test + @TestMetadata("assignArrayToVararagInNamedForm_1_3.kt") + public void testAssignArrayToVararagInNamedForm_1_3() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_3.kt"); + } + + @Test + @TestMetadata("assignArrayToVararagInNamedForm_1_4.kt") + public void testAssignArrayToVararagInNamedForm_1_4() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_4.kt"); + } + + @Test + @TestMetadata("assignNonConstSingleArrayElementAsVarargInAnnotation.kt") + public void testAssignNonConstSingleArrayElementAsVarargInAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotation.kt"); + } + + @Test + @TestMetadata("assignNonConstSingleArrayElementAsVarargInAnnotationError.kt") + public void testAssignNonConstSingleArrayElementAsVarargInAnnotationError() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotationError.kt"); + } + + @Test + @TestMetadata("assigningArraysToVarargsInAnnotations.kt") + public void testAssigningArraysToVarargsInAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/assigningArraysToVarargsInAnnotations.kt"); + } + + @Test + @TestMetadata("assigningSingleElementsInNamedFormAnnDeprecation_after.kt") + public void testAssigningSingleElementsInNamedFormAnnDeprecation_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormAnnDeprecation_after.kt"); + } + + @Test + @TestMetadata("assigningSingleElementsInNamedFormAnnDeprecation_before.kt") + public void testAssigningSingleElementsInNamedFormAnnDeprecation_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormAnnDeprecation_before.kt"); + } + + @Test + @TestMetadata("assigningSingleElementsInNamedFormFunDeprecation_after.kt") + public void testAssigningSingleElementsInNamedFormFunDeprecation_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_after.kt"); + } + + @Test + @TestMetadata("assigningSingleElementsInNamedFormFunDeprecation_before.kt") + public void testAssigningSingleElementsInNamedFormFunDeprecation_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_before.kt"); + } + + @Test + @TestMetadata("inferredNullableArrayAsVararg.kt") + public void testInferredNullableArrayAsVararg() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/inferredNullableArrayAsVararg.kt"); + } + + @Test + @TestMetadata("kt10926.kt") + public void testKt10926() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/kt10926.kt"); + } + + @Test + @TestMetadata("kt10926EnabledFeature.kt") + public void testKt10926EnabledFeature() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/kt10926EnabledFeature.kt"); + } + + @Test + @TestMetadata("kt1781.kt") + public void testKt1781() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/kt1781.kt"); + } + + @Test + @TestMetadata("kt1835.kt") + public void testKt1835() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/kt1835.kt"); + } + + @Test + @TestMetadata("kt1838-param.kt") + public void testKt1838_param() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/kt1838-param.kt"); + } + + @Test + @TestMetadata("kt1838-val.kt") + public void testKt1838_val() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/kt1838-val.kt"); + } + + @Test + @TestMetadata("kt2163.kt") + public void testKt2163() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/kt2163.kt"); + } + + @Test + @TestMetadata("kt422.kt") + public void testKt422() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/kt422.kt"); + } + + @Test + @TestMetadata("kt48162.kt") + public void testKt48162() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/kt48162.kt"); + } + + @Test + @TestMetadata("MoreSpecificVarargsOfEqualLength.kt") + public void testMoreSpecificVarargsOfEqualLength() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/MoreSpecificVarargsOfEqualLength.kt"); + } + + @Test + @TestMetadata("MostSepcificVarargsWithJava.kt") + public void testMostSepcificVarargsWithJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/MostSepcificVarargsWithJava.kt"); + } + + @Test + @TestMetadata("NilaryVsVararg.kt") + public void testNilaryVsVararg() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/NilaryVsVararg.kt"); + } + + @Test + @TestMetadata("NullableTypeForVarargArgument.kt") + public void testNullableTypeForVarargArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/NullableTypeForVarargArgument.kt"); + } + + @Test + @TestMetadata("prohibitAssigningSingleElementsInNamedForm.kt") + public void testProhibitAssigningSingleElementsInNamedForm() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/prohibitAssigningSingleElementsInNamedForm.kt"); + } + + @Test + @TestMetadata("UnaryVsVararg.kt") + public void testUnaryVsVararg() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/UnaryVsVararg.kt"); + } + + @Test + @TestMetadata("varargInSetter.kt") + public void testVarargInSetter() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/varargInSetter.kt"); + } + + @Test + @TestMetadata("varargIterator.kt") + public void testVarargIterator() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/varargIterator.kt"); + } + + @Test + @TestMetadata("varargOfNothing.kt") + public void testVarargOfNothing() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/varargOfNothing.kt"); + } + + @Test + @TestMetadata("varargViewedAsArray.kt") + public void testVarargViewedAsArray() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/varargViewedAsArray.kt"); + } + + @Test + @TestMetadata("varargsAndFunctionLiterals.kt") + public void testVarargsAndFunctionLiterals() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/varargsAndFunctionLiterals.kt"); + } + + @Test + @TestMetadata("varargsAndOut1.kt") + public void testVarargsAndOut1() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/varargsAndOut1.kt"); + } + + @Test + @TestMetadata("varargsAndOut2.kt") + public void testVarargsAndOut2() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/varargsAndOut2.kt"); + } + + @Test + @TestMetadata("varargsAndPair.kt") + public void testVarargsAndPair() throws Exception { + runTest("compiler/testData/diagnostics/tests/varargs/varargsAndPair.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/variance") + @TestDataPath("$PROJECT_ROOT") + public class Variance { + @Test + public void testAllFilesPresentInVariance() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/variance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("Class.kt") + public void testClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/variance/Class.kt"); + } + + @Test + @TestMetadata("ea1337846.kt") + public void testEa1337846() throws Exception { + runTest("compiler/testData/diagnostics/tests/variance/ea1337846.kt"); + } + + @Test + @TestMetadata("Function.kt") + public void testFunction() throws Exception { + runTest("compiler/testData/diagnostics/tests/variance/Function.kt"); + } + + @Test + @TestMetadata("FunctionTypes.kt") + public void testFunctionTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/variance/FunctionTypes.kt"); + } + + @Test + @TestMetadata("InPosition.kt") + public void testInPosition() throws Exception { + runTest("compiler/testData/diagnostics/tests/variance/InPosition.kt"); + } + + @Test + @TestMetadata("InvariantPosition.kt") + public void testInvariantPosition() throws Exception { + runTest("compiler/testData/diagnostics/tests/variance/InvariantPosition.kt"); + } + + @Test + @TestMetadata("NullableTypes.kt") + public void testNullableTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/variance/NullableTypes.kt"); + } + + @Test + @TestMetadata("OutPosition.kt") + public void testOutPosition() throws Exception { + runTest("compiler/testData/diagnostics/tests/variance/OutPosition.kt"); + } + + @Test + @TestMetadata("PrimaryConstructor.kt") + public void testPrimaryConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/variance/PrimaryConstructor.kt"); + } + + @Test + @TestMetadata("ValProperty.kt") + public void testValProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/variance/ValProperty.kt"); + } + + @Test + @TestMetadata("VarProperty.kt") + public void testVarProperty() throws Exception { + runTest("compiler/testData/diagnostics/tests/variance/VarProperty.kt"); + } + + @Test + @TestMetadata("Visibility.kt") + public void testVisibility() throws Exception { + runTest("compiler/testData/diagnostics/tests/variance/Visibility.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/variance/privateToThis") + @TestDataPath("$PROJECT_ROOT") + public class PrivateToThis { + @Test + @TestMetadata("Abstract.kt") + public void testAbstract() throws Exception { + runTest("compiler/testData/diagnostics/tests/variance/privateToThis/Abstract.kt"); + } + + @Test + public void testAllFilesPresentInPrivateToThis() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/variance/privateToThis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("FunctionCall.kt") + public void testFunctionCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/variance/privateToThis/FunctionCall.kt"); + } + + @Test + @TestMetadata("GetVal.kt") + public void testGetVal() throws Exception { + runTest("compiler/testData/diagnostics/tests/variance/privateToThis/GetVal.kt"); + } + + @Test + @TestMetadata("SetVar.kt") + public void testSetVar() throws Exception { + runTest("compiler/testData/diagnostics/tests/variance/privateToThis/SetVar.kt"); + } + + @Test + @TestMetadata("ValReassigned.kt") + public void testValReassigned() throws Exception { + runTest("compiler/testData/diagnostics/tests/variance/privateToThis/ValReassigned.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/visibility") + @TestDataPath("$PROJECT_ROOT") + public class Visibility { + @Test + @TestMetadata("abstractInvisibleMemberFromJava.kt") + public void testAbstractInvisibleMemberFromJava() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/abstractInvisibleMemberFromJava.kt"); + } + + @Test + @TestMetadata("abstractInvisibleMemberFromKotlin.kt") + public void testAbstractInvisibleMemberFromKotlin() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/abstractInvisibleMemberFromKotlin.kt"); + } + + @Test + @TestMetadata("abstractInvisibleMemberFromKotlinWarning.kt") + public void testAbstractInvisibleMemberFromKotlinWarning() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/abstractInvisibleMemberFromKotlinWarning.kt"); + } + + @Test + public void testAllFilesPresentInVisibility() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/visibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("innerClassDelegatingConstructorCallToPrivate.kt") + public void testInnerClassDelegatingConstructorCallToPrivate() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/innerClassDelegatingConstructorCallToPrivate.kt"); + } + + @Test + @TestMetadata("innerConstructorThroughSubclass.kt") + public void testInnerConstructorThroughSubclass() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/innerConstructorThroughSubclass.kt"); + } + + @Test + @TestMetadata("innerNestedAndAnonymousClasses.kt") + public void testInnerNestedAndAnonymousClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/innerNestedAndAnonymousClasses.kt"); + } + + @Test + @TestMetadata("invisiblePrivateThroughSubClass.kt") + public void testInvisiblePrivateThroughSubClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/invisiblePrivateThroughSubClass.kt"); + } + + @Test + @TestMetadata("invisiblePrivateThroughSubClassDoubleSmartCast.kt") + public void testInvisiblePrivateThroughSubClassDoubleSmartCast() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/invisiblePrivateThroughSubClassDoubleSmartCast.kt"); + } + + @Test + @TestMetadata("invisiblePrivateThroughSubClassSmartCast.kt") + public void testInvisiblePrivateThroughSubClassSmartCast() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/invisiblePrivateThroughSubClassSmartCast.kt"); + } + + @Test + @TestMetadata("invisibleSetterOfJavaClass.kt") + public void testInvisibleSetterOfJavaClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/invisibleSetterOfJavaClass.kt"); + } + + @Test + @TestMetadata("invisibleSetterOfJavaClassWithDisabledFeature.kt") + public void testInvisibleSetterOfJavaClassWithDisabledFeature() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/invisibleSetterOfJavaClassWithDisabledFeature.kt"); + } + + @Test + @TestMetadata("javaInterfaceFieldDirectAccess.kt") + public void testJavaInterfaceFieldDirectAccess() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/javaInterfaceFieldDirectAccess.kt"); + } + + @Test + @TestMetadata("kt56283.kt") + public void testKt56283() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/kt56283.kt"); + } + + @Test + @TestMetadata("lackOfInvisibleSetterOfJavaClassInSamePackage.kt") + public void testLackOfInvisibleSetterOfJavaClassInSamePackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/lackOfInvisibleSetterOfJavaClassInSamePackage.kt"); + } + + @Test + @TestMetadata("moreSpecificProtected.kt") + public void testMoreSpecificProtected() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/moreSpecificProtected.kt"); + } + + @Test + @TestMetadata("moreSpecificProtectedSimple.kt") + public void testMoreSpecificProtectedSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/moreSpecificProtectedSimple.kt"); + } + + @Test + @TestMetadata("notOverridingInternal.kt") + public void testNotOverridingInternal() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/notOverridingInternal.kt"); + } + + @Test + @TestMetadata("notOverridingPackagePrivate.kt") + public void testNotOverridingPackagePrivate() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/notOverridingPackagePrivate.kt"); + } + + @Test + @TestMetadata("overrideOfMemberInPackagePrivateClass.kt") + public void testOverrideOfMemberInPackagePrivateClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/overrideOfMemberInPackagePrivateClass.kt"); + } + + @Test + @TestMetadata("packagePrivateStatic.kt") + public void testPackagePrivateStatic() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/packagePrivateStatic.kt"); + } + + @Test + @TestMetadata("packagePrivateStaticInterfaceFieldViaKotlinClass.kt") + public void testPackagePrivateStaticInterfaceFieldViaKotlinClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/packagePrivateStaticInterfaceFieldViaKotlinClass.kt"); + } + + @Test + @TestMetadata("packagePrivateStaticInterfaceMethod.kt") + public void testPackagePrivateStaticInterfaceMethod() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/packagePrivateStaticInterfaceMethod.kt"); + } + + @Test + @TestMetadata("packagePrivateStaticViaInternal.kt") + public void testPackagePrivateStaticViaInternal() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/packagePrivateStaticViaInternal.kt"); + } + + @Test + @TestMetadata("packagePrivateStaticViaTypeAlias.kt") + public void testPackagePrivateStaticViaTypeAlias() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/packagePrivateStaticViaTypeAlias.kt"); + } + + @Test + @TestMetadata("privateCompanionInSuperClass.kt") + public void testPrivateCompanionInSuperClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/privateCompanionInSuperClass.kt"); + } + + @Test + @TestMetadata("privateDeclarationInAnotherFile.kt") + public void testPrivateDeclarationInAnotherFile() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/privateDeclarationInAnotherFile.kt"); + } + + @Test + @TestMetadata("privateFromInAnonymousObject.kt") + public void testPrivateFromInAnonymousObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/privateFromInAnonymousObject.kt"); + } + + @Test + @TestMetadata("privateToThis.kt") + public void testPrivateToThis() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/privateToThis.kt"); + } + + @Test + @TestMetadata("protectedInternal.kt") + public void testProtectedInternal() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/protectedInternal.kt"); + } + + @Test + @TestMetadata("protectedVisibilityAndSmartcast_fakeOverride.kt") + public void testProtectedVisibilityAndSmartcast_fakeOverride() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/protectedVisibilityAndSmartcast_fakeOverride.kt"); + } + + @Test + @TestMetadata("protectedVisibilityAndSmartcast_noOverride.kt") + public void testProtectedVisibilityAndSmartcast_noOverride() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/protectedVisibilityAndSmartcast_noOverride.kt"); + } + + @Test + @TestMetadata("protectedVisibilityAndSmartcast_overrideChangesType.kt") + public void testProtectedVisibilityAndSmartcast_overrideChangesType() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/protectedVisibilityAndSmartcast_overrideChangesType.kt"); + } + + @Test + @TestMetadata("protectedVisibilityAndSmartcast_overrideSameType.kt") + public void testProtectedVisibilityAndSmartcast_overrideSameType() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/protectedVisibilityAndSmartcast_overrideSameType.kt"); + } + + @Test + @TestMetadata("smartCastAndSuppressedVisibility.kt") + public void testSmartCastAndSuppressedVisibility() throws Exception { + runTest("compiler/testData/diagnostics/tests/visibility/smartCastAndSuppressedVisibility.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/warningsForBreakingChanges") + @TestDataPath("$PROJECT_ROOT") + public class WarningsForBreakingChanges { + @Test + public void testAllFilesPresentInWarningsForBreakingChanges() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/warningsForBreakingChanges"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/warningsForBreakingChanges/capturedTypes") + @TestDataPath("$PROJECT_ROOT") + public class CapturedTypes { + @Test + public void testAllFilesPresentInCapturedTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/warningsForBreakingChanges/capturedTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("incorrectCapturedApproximationForValueParameters.kt") + public void testIncorrectCapturedApproximationForValueParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/warningsForBreakingChanges/capturedTypes/incorrectCapturedApproximationForValueParameters.kt"); + } + + @Test + @TestMetadata("noWarningAfterSmartcast.kt") + public void testNoWarningAfterSmartcast() throws Exception { + runTest("compiler/testData/diagnostics/tests/warningsForBreakingChanges/capturedTypes/noWarningAfterSmartcast.kt"); + } + + @Test + @TestMetadata("noWarningOnSAMAdaption.kt") + public void testNoWarningOnSAMAdaption() throws Exception { + runTest("compiler/testData/diagnostics/tests/warningsForBreakingChanges/capturedTypes/noWarningOnSAMAdaption.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/when") + @TestDataPath("$PROJECT_ROOT") + public class When { + @Test + public void testAllFilesPresentInWhen() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/when"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("AnnotatedWhenStatement.kt") + public void testAnnotatedWhenStatement() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/AnnotatedWhenStatement.kt"); + } + + @Test + @TestMetadata("BranchBypassVal.kt") + public void testBranchBypassVal() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/BranchBypassVal.kt"); + } + + @Test + @TestMetadata("BranchBypassVar.kt") + public void testBranchBypassVar() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/BranchBypassVar.kt"); + } + + @Test + @TestMetadata("BranchFalseBypass.kt") + public void testBranchFalseBypass() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/BranchFalseBypass.kt"); + } + + @Test + @TestMetadata("BranchFalseBypassElse.kt") + public void testBranchFalseBypassElse() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/BranchFalseBypassElse.kt"); + } + + @Test + @TestMetadata("CommaInWhenConditionWithoutArgument.kt") + public void testCommaInWhenConditionWithoutArgument() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/CommaInWhenConditionWithoutArgument.kt"); + } + + @Test + @TestMetadata("deprecatedSyntaxInConditionsNoSubject.kt") + public void testDeprecatedSyntaxInConditionsNoSubject() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/deprecatedSyntaxInConditionsNoSubject.kt"); + } + + @Test + @TestMetadata("deprecatedSyntaxInConditions_after.kt") + public void testDeprecatedSyntaxInConditions_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/deprecatedSyntaxInConditions_after.kt"); + } + + @Test + @TestMetadata("deprecatedSyntaxInConditions_before.kt") + public void testDeprecatedSyntaxInConditions_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/deprecatedSyntaxInConditions_before.kt"); + } + + @Test + @TestMetadata("DuplicatedLabels.kt") + public void testDuplicatedLabels() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/DuplicatedLabels.kt"); + } + + @Test + @TestMetadata("ElseOnNullableEnum.kt") + public void testElseOnNullableEnum() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ElseOnNullableEnum.kt"); + } + + @Test + @TestMetadata("ElseOnNullableEnumWithSmartCast.kt") + public void testElseOnNullableEnumWithSmartCast() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ElseOnNullableEnumWithSmartCast.kt"); + } + + @Test + @TestMetadata("EmptyConditionWithExpression.kt") + public void testEmptyConditionWithExpression() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/EmptyConditionWithExpression.kt"); + } + + @Test + @TestMetadata("EmptyConditionWithExpressionEnum.kt") + public void testEmptyConditionWithExpressionEnum() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/EmptyConditionWithExpressionEnum.kt"); + } + + @Test + @TestMetadata("ExhaustiveBoolean.kt") + public void testExhaustiveBoolean() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ExhaustiveBoolean.kt"); + } + + @Test + @TestMetadata("ExhaustiveBooleanBrackets.kt") + public void testExhaustiveBooleanBrackets() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ExhaustiveBooleanBrackets.kt"); + } + + @Test + @TestMetadata("ExhaustiveBooleanComplex.kt") + public void testExhaustiveBooleanComplex() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ExhaustiveBooleanComplex.kt"); + } + + @Test + @TestMetadata("ExhaustiveBooleanNullable.kt") + public void testExhaustiveBooleanNullable() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ExhaustiveBooleanNullable.kt"); + } + + @Test + @TestMetadata("exhaustiveBooleanWhenWithUntrivialConst_error.kt") + public void testExhaustiveBooleanWhenWithUntrivialConst_error() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/exhaustiveBooleanWhenWithUntrivialConst_error.kt"); + } + + @Test + @TestMetadata("exhaustiveBooleanWhenWithUntrivialConst_warning.kt") + public void testExhaustiveBooleanWhenWithUntrivialConst_warning() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/exhaustiveBooleanWhenWithUntrivialConst_warning.kt"); + } + + @Test + @TestMetadata("ExhaustiveBreakContinue.kt") + public void testExhaustiveBreakContinue() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ExhaustiveBreakContinue.kt"); + } + + @Test + @TestMetadata("ExhaustiveEnumIs.kt") + public void testExhaustiveEnumIs() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ExhaustiveEnumIs.kt"); + } + + @Test + @TestMetadata("ExhaustiveEnumMixed.kt") + public void testExhaustiveEnumMixed() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ExhaustiveEnumMixed.kt"); + } + + @Test + @TestMetadata("ExhaustiveInitialization.kt") + public void testExhaustiveInitialization() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ExhaustiveInitialization.kt"); + } + + @Test + @TestMetadata("ExhaustiveNoInitialization.kt") + public void testExhaustiveNoInitialization() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ExhaustiveNoInitialization.kt"); + } + + @Test + @TestMetadata("ExhaustiveNullable.kt") + public void testExhaustiveNullable() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ExhaustiveNullable.kt"); + } + + @Test + @TestMetadata("ExhaustivePlatformBoolean.kt") + public void testExhaustivePlatformBoolean() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ExhaustivePlatformBoolean.kt"); + } + + @Test + @TestMetadata("ExhaustivePlatformEnum.kt") + public void testExhaustivePlatformEnum() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnum.kt"); + } + + @Test + @TestMetadata("ExhaustivePlatformEnumAnnotated.kt") + public void testExhaustivePlatformEnumAnnotated() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnumAnnotated.kt"); + } + + @Test + @TestMetadata("ExhaustivePlatformEnumElse.kt") + public void testExhaustivePlatformEnumElse() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnumElse.kt"); + } + + @Test + @TestMetadata("ExhaustivePlatformEnumNull.kt") + public void testExhaustivePlatformEnumNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnumNull.kt"); + } + + @Test + @TestMetadata("ExhaustivePlatformEnumStatement.kt") + public void testExhaustivePlatformEnumStatement() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnumStatement.kt"); + } + + @Test + @TestMetadata("ExhaustiveReturn.kt") + public void testExhaustiveReturn() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ExhaustiveReturn.kt"); + } + + @Test + @TestMetadata("ExhaustiveReturnThrow.kt") + public void testExhaustiveReturnThrow() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ExhaustiveReturnThrow.kt"); + } + + @Test + @TestMetadata("ExhaustiveValOverConditionalInit.kt") + public void testExhaustiveValOverConditionalInit() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ExhaustiveValOverConditionalInit.kt"); + } + + @Test + @TestMetadata("ExhaustiveVarOverConditionalInit.kt") + public void testExhaustiveVarOverConditionalInit() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ExhaustiveVarOverConditionalInit.kt"); + } + + @Test + @TestMetadata("exhaustiveWhenWithConstVal.kt") + public void testExhaustiveWhenWithConstVal() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/exhaustiveWhenWithConstVal.kt"); + } + + @Test + @TestMetadata("ExhaustiveWithNullabilityCheck.kt") + public void testExhaustiveWithNullabilityCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheck.kt"); + } + + @Test + @TestMetadata("ExhaustiveWithNullabilityCheckBefore.kt") + public void testExhaustiveWithNullabilityCheckBefore() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckBefore.kt"); + } + + @Test + @TestMetadata("ExhaustiveWithNullabilityCheckBoolean.kt") + public void testExhaustiveWithNullabilityCheckBoolean() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckBoolean.kt"); + } + + @Test + @TestMetadata("ExhaustiveWithNullabilityCheckElse.kt") + public void testExhaustiveWithNullabilityCheckElse() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckElse.kt"); + } + + @Test + @TestMetadata("extractingEntireCall.kt") + public void testExtractingEntireCall() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/extractingEntireCall.kt"); + } + + @Test + @TestMetadata("flexibleEnumInSubject.kt") + public void testFlexibleEnumInSubject() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/flexibleEnumInSubject.kt"); + } + + @Test + @TestMetadata("intersectionExhaustivenessComplex.kt") + public void testIntersectionExhaustivenessComplex() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/intersectionExhaustivenessComplex.kt"); + } + + @Test + @TestMetadata("intersectionExhaustivenessSimple.kt") + public void testIntersectionExhaustivenessSimple() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/intersectionExhaustivenessSimple.kt"); + } + + @Test + @TestMetadata("kt10439.kt") + public void testKt10439() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/kt10439.kt"); + } + + @Test + @TestMetadata("kt10809.kt") + public void testKt10809() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/kt10809.kt"); + } + + @Test + @TestMetadata("kt10811.kt") + public void testKt10811() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/kt10811.kt"); + } + + @Test + @TestMetadata("kt4434.kt") + public void testKt4434() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/kt4434.kt"); + } + + @Test + @TestMetadata("kt47922.kt") + public void testKt47922() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/kt47922.kt"); + } + + @Test + @TestMetadata("kt48653_after.kt") + public void testKt48653_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/kt48653_after.kt"); + } + + @Test + @TestMetadata("kt48653_before.kt") + public void testKt48653_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/kt48653_before.kt"); + } + + @Test + @TestMetadata("kt49702.kt") + public void testKt49702() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/kt49702.kt"); + } + + @Test + @TestMetadata("kt9929.kt") + public void testKt9929() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/kt9929.kt"); + } + + @Test + @TestMetadata("kt9972.kt") + public void testKt9972() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/kt9972.kt"); + } + + @Test + @TestMetadata("NoElseExpectedUnit.kt") + public void testNoElseExpectedUnit() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/NoElseExpectedUnit.kt"); + } + + @Test + @TestMetadata("NoElseNoExpectedType.kt") + public void testNoElseNoExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/NoElseNoExpectedType.kt"); + } + + @Test + @TestMetadata("NoElseReturnedCoercionToUnit.kt") + public void testNoElseReturnedCoercionToUnit() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/NoElseReturnedCoercionToUnit.kt"); + } + + @Test + @TestMetadata("NoElseReturnedFromLambdaExpectedInt.kt") + public void testNoElseReturnedFromLambdaExpectedInt() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/NoElseReturnedFromLambdaExpectedInt.kt"); + } + + @Test + @TestMetadata("NoElseReturnedNonUnit.kt") + public void testNoElseReturnedNonUnit() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/NoElseReturnedNonUnit.kt"); + } + + @Test + @TestMetadata("NoElseReturnedUnit.kt") + public void testNoElseReturnedUnit() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/NoElseReturnedUnit.kt"); + } + + @Test + @TestMetadata("NoElseWhenStatement.kt") + public void testNoElseWhenStatement() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/NoElseWhenStatement.kt"); + } + + @Test + @TestMetadata("NonExhaustiveBooleanNullable.kt") + public void testNonExhaustiveBooleanNullable() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/NonExhaustiveBooleanNullable.kt"); + } + + @Test + @TestMetadata("nonExhaustiveDependentContext.kt") + public void testNonExhaustiveDependentContext() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/nonExhaustiveDependentContext.kt"); + } + + @Test + @TestMetadata("NonExhaustivePlatformEnum.kt") + public void testNonExhaustivePlatformEnum() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/NonExhaustivePlatformEnum.kt"); + } + + @Test + @TestMetadata("NonExhaustiveWarning.kt") + public void testNonExhaustiveWarning() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/NonExhaustiveWarning.kt"); + } + + @Test + @TestMetadata("NonExhaustiveWarningElse.kt") + public void testNonExhaustiveWarningElse() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/NonExhaustiveWarningElse.kt"); + } + + @Test + @TestMetadata("NonExhaustiveWarningFalse.kt") + public void testNonExhaustiveWarningFalse() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/NonExhaustiveWarningFalse.kt"); + } + + @Test + @TestMetadata("NonExhaustiveWarningForSealedClass.kt") + public void testNonExhaustiveWarningForSealedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/NonExhaustiveWarningForSealedClass.kt"); + } + + @Test + @TestMetadata("NonExhaustiveWarningNull.kt") + public void testNonExhaustiveWarningNull() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/NonExhaustiveWarningNull.kt"); + } + + @Test + @TestMetadata("nonExhaustiveWhenStatement_1_5.kt") + public void testNonExhaustiveWhenStatement_1_5() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/nonExhaustiveWhenStatement_1_5.kt"); + } + + @Test + @TestMetadata("nonExhaustiveWhenStatement_1_6.kt") + public void testNonExhaustiveWhenStatement_1_6() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/nonExhaustiveWhenStatement_1_6.kt"); + } + + @Test + @TestMetadata("nonExhaustiveWhenStatement_1_7.kt") + public void testNonExhaustiveWhenStatement_1_7() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/nonExhaustiveWhenStatement_1_7.kt"); + } + + @Test + @TestMetadata("NonExhaustiveWithNullabilityCheck.kt") + public void testNonExhaustiveWithNullabilityCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/NonExhaustiveWithNullabilityCheck.kt"); + } + + @Test + @TestMetadata("PropertyNotInitialized.kt") + public void testPropertyNotInitialized() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/PropertyNotInitialized.kt"); + } + + @Test + @TestMetadata("RedundantElse.kt") + public void testRedundantElse() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/RedundantElse.kt"); + } + + @Test + @TestMetadata("ReservedExhaustiveWhen.kt") + public void testReservedExhaustiveWhen() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/ReservedExhaustiveWhen.kt"); + } + + @Test + @TestMetadata("TopLevelSealed.kt") + public void testTopLevelSealed() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/TopLevelSealed.kt"); + } + + @Test + @TestMetadata("TypeParameterError.kt") + public void testTypeParameterError() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/TypeParameterError.kt"); + } + + @Test + @TestMetadata("TypeParameterWarning.kt") + public void testTypeParameterWarning() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/TypeParameterWarning.kt"); + } + + @Test + @TestMetadata("When.kt") + public void testWhen() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/When.kt"); + } + + @Test + @TestMetadata("whenAndLambdaWithExpectedType.kt") + public void testWhenAndLambdaWithExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/whenAndLambdaWithExpectedType.kt"); + } + + @Test + @TestMetadata("whenOnClass.kt") + public void testWhenOnClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/whenOnClass.kt"); + } + + @Test + @TestMetadata("whenOnNothing.kt") + public void testWhenOnNothing() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/whenOnNothing.kt"); + } + + @Test + @TestMetadata("WhenTypeDisjunctions.kt") + public void testWhenTypeDisjunctions() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/WhenTypeDisjunctions.kt"); + } + + @Test + @TestMetadata("whenWithNothingAndLambdas.kt") + public void testWhenWithNothingAndLambdas() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/whenWithNothingAndLambdas.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/when/withSubjectVariable") + @TestDataPath("$PROJECT_ROOT") + public class WithSubjectVariable { + @Test + public void testAllFilesPresentInWithSubjectVariable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/when/withSubjectVariable"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "multiplatform"); + } + + @Test + @TestMetadata("capturingInInitializer.kt") + public void testCapturingInInitializer() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/capturingInInitializer.kt"); + } + + @Test + @TestMetadata("invisibleOutsideOfWhen.kt") + public void testInvisibleOutsideOfWhen() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/invisibleOutsideOfWhen.kt"); + } + + @Test + @TestMetadata("jumpoutInInitializer.kt") + public void testJumpoutInInitializer() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/jumpoutInInitializer.kt"); + } + + @Test + @TestMetadata("nestedWhenWithSubject.kt") + public void testNestedWhenWithSubject() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/nestedWhenWithSubject.kt"); + } + + @Test + @TestMetadata("noSubjectVariableName.kt") + public void testNoSubjectVariableName() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/noSubjectVariableName.kt"); + } + + @Test + @TestMetadata("reassignmentToWhenSubjectVariable.kt") + public void testReassignmentToWhenSubjectVariable() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/reassignmentToWhenSubjectVariable.kt"); + } + + @Test + @TestMetadata("shadowingOtherVariable.kt") + public void testShadowingOtherVariable() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/shadowingOtherVariable.kt"); + } + + @Test + @TestMetadata("smartCastOnValueBoundToSubjectVariable.kt") + public void testSmartCastOnValueBoundToSubjectVariable() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/smartCastOnValueBoundToSubjectVariable.kt"); + } + + @Test + @TestMetadata("smartCastsOnSubjectVariable.kt") + public void testSmartCastsOnSubjectVariable() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/smartCastsOnSubjectVariable.kt"); + } + + @Test + @TestMetadata("smartcastToEnum.kt") + public void testSmartcastToEnum() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/smartcastToEnum.kt"); + } + + @Test + @TestMetadata("smartcastToSealed.kt") + public void testSmartcastToSealed() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/smartcastToSealed.kt"); + } + + @Test + @TestMetadata("softModifierName.kt") + public void testSoftModifierName() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/softModifierName.kt"); + } + + @Test + @TestMetadata("subjectVariableInIsPattern.kt") + public void testSubjectVariableInIsPattern() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/subjectVariableInIsPattern.kt"); + } + + @Test + @TestMetadata("unsupportedFeature.kt") + public void testUnsupportedFeature() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/unsupportedFeature.kt"); + } + + @Test + @TestMetadata("unsupportedVariableDeclarationsInWhenSubject.kt") + public void testUnsupportedVariableDeclarationsInWhenSubject() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/unsupportedVariableDeclarationsInWhenSubject.kt"); + } + + @Test + @TestMetadata("unusedWhenSubjectVariable.kt") + public void testUnusedWhenSubjectVariable() throws Exception { + runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/unusedWhenSubjectVariable.kt"); + } + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib") + @TestDataPath("$PROJECT_ROOT") + public class TestsWithStdLib { + @Test + @TestMetadata("addAllProjection.kt") + public void testAddAllProjection() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/addAllProjection.kt"); + } + + @Test + public void testAllFilesPresentInTestsWithStdLib() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "native"); + } + + @Test + @TestMetadata("ArrayOfNothing.kt") + public void testArrayOfNothing() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/ArrayOfNothing.kt"); + } + + @Test + @TestMetadata("assignedInSynchronized.kt") + public void testAssignedInSynchronized() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/assignedInSynchronized.kt"); + } + + @Test + @TestMetadata("buildLazyValueForMap.kt") + public void testBuildLazyValueForMap() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/buildLazyValueForMap.kt"); + } + + @Test + @TestMetadata("CallCompanionProtectedNonStatic.kt") + public void testCallCompanionProtectedNonStatic() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/CallCompanionProtectedNonStatic.kt"); + } + + @Test + @TestMetadata("CallToMainRedeclaredInMultiFile.kt") + public void testCallToMainRedeclaredInMultiFile() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/CallToMainRedeclaredInMultiFile.kt"); + } + + @Test + @TestMetadata("commonCollections.kt") + public void testCommonCollections() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/commonCollections.kt"); + } + + @Test + @TestMetadata("compileTimeUnsignedArray.kt") + public void testCompileTimeUnsignedArray() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/compileTimeUnsignedArray.kt"); + } + + @Test + @TestMetadata("elvisOnJavaList.kt") + public void testElvisOnJavaList() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/elvisOnJavaList.kt"); + } + + @Test + @TestMetadata("elvisOnUnitInLet.kt") + public void testElvisOnUnitInLet() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/elvisOnUnitInLet.kt"); + } + + @Test + @TestMetadata("enumEntryInitialization.kt") + public void testEnumEntryInitialization() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/enumEntryInitialization.kt"); + } + + @Test + @TestMetadata("exitProcess.kt") + public void testExitProcess() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/exitProcess.kt"); + } + + @Test + @TestMetadata("genericContainer.kt") + public void testGenericContainer() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/genericContainer.kt"); + } + + @Test + @TestMetadata("greater.kt") + public void testGreater() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/greater.kt"); + } + + @Test + @TestMetadata("hugeUnresolvedKotlinxHtml.kt") + public void testHugeUnresolvedKotlinxHtml() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/hugeUnresolvedKotlinxHtml.kt"); + } + + @Test + @TestMetadata("ifElseJavaList.kt") + public void testIfElseJavaList() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/ifElseJavaList.kt"); + } + + @Test + @TestMetadata("implicitCastToAny.kt") + public void testImplicitCastToAny() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/implicitCastToAny.kt"); + } + + @Test + @TestMetadata("implicitNothingInDelegate.kt") + public void testImplicitNothingInDelegate() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/implicitNothingInDelegate.kt"); + } + + @Test + @TestMetadata("InaccessibleInternalClass.kt") + public void testInaccessibleInternalClass() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/InaccessibleInternalClass.kt"); + } + + @Test + @TestMetadata("instar.kt") + public void testInstar() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/instar.kt"); + } + + @Test + @TestMetadata("javaClassOnCompanion.kt") + public void testJavaClassOnCompanion() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/javaClassOnCompanion.kt"); + } + + @Test + @TestMetadata("javaForKClass.kt") + public void testJavaForKClass() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/javaForKClass.kt"); + } + + @Test + @TestMetadata("jvmFieldAndJavaGetter.kt") + public void testJvmFieldAndJavaGetter() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/jvmFieldAndJavaGetter.kt"); + } + + @Test + @TestMetadata("kt54410.kt") + public void testKt54410() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/kt54410.kt"); + } + + @Test + @TestMetadata("kt55503.kt") + public void testKt55503() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/kt55503.kt"); + } + + @Test + @TestMetadata("kt55503_2.kt") + public void testKt55503_2() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/kt55503_2.kt"); + } + + @Test + @TestMetadata("kt55747.kt") + public void testKt55747() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/kt55747.kt"); + } + + @Test + @TestMetadata("kt8050.kt") + public void testKt8050() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/kt8050.kt"); + } + + @Test + @TestMetadata("kt9078.kt") + public void testKt9078() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/kt9078.kt"); + } + + @Test + @TestMetadata("kt9985.kt") + public void testKt9985() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/kt9985.kt"); + } + + @Test + @TestMetadata("labelClashes.kt") + public void testLabelClashes() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/labelClashes.kt"); + } + + @Test + @TestMetadata("labelClashesWithContextReceivers.kt") + public void testLabelClashesWithContextReceivers() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/labelClashesWithContextReceivers.kt"); + } + + @Test + @TestMetadata("outstar.kt") + public void testOutstar() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/outstar.kt"); + } + + @Test + @TestMetadata("overrideWithFunctionalType.kt") + public void testOverrideWithFunctionalType() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/overrideWithFunctionalType.kt"); + } + + @Test + @TestMetadata("pairReference.kt") + public void testPairReference() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/pairReference.kt"); + } + + @Test + @TestMetadata("PropertyDelegateWithPrivateSet.kt") + public void testPropertyDelegateWithPrivateSet() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/PropertyDelegateWithPrivateSet.kt"); + } + + @Test + @TestMetadata("pureReifiable.kt") + public void testPureReifiable() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/pureReifiable.kt"); + } + + @Test + @TestMetadata("pureReifiableArrayOperations.kt") + public void testPureReifiableArrayOperations() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/pureReifiableArrayOperations.kt"); + } + + @Test + @TestMetadata("RedeclarationMainInMultiFileClass.kt") + public void testRedeclarationMainInMultiFileClass() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/RedeclarationMainInMultiFileClass.kt"); + } + + @Test + @TestMetadata("RenameOnImportHidesDefaultImport.kt") + public void testRenameOnImportHidesDefaultImport() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/RenameOnImportHidesDefaultImport.kt"); + } + + @Test + @TestMetadata("shadowingInDestructuring.kt") + public void testShadowingInDestructuring() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/shadowingInDestructuring.kt"); + } + + @Test + @TestMetadata("streams.kt") + public void testStreams() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/streams.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations") + @TestDataPath("$PROJECT_ROOT") + public class Annotations { + @Test + public void testAllFilesPresentInAnnotations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("annotationTargetResolvedAmbiguously.kt") + public void testAnnotationTargetResolvedAmbiguously() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationTargetResolvedAmbiguously.kt"); + } + + @Test + @TestMetadata("annotationsTargetingLateinitAccessors.kt") + public void testAnnotationsTargetingLateinitAccessors() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationsTargetingLateinitAccessors.kt"); + } + + @Test + @TestMetadata("annotationsTargetingNonExistentAccessor.kt") + public void testAnnotationsTargetingNonExistentAccessor() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationsTargetingNonExistentAccessor.kt"); + } + + @Test + @TestMetadata("ClassObjectAnnotatedWithItsKClass.kt") + public void testClassObjectAnnotatedWithItsKClass() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/ClassObjectAnnotatedWithItsKClass.kt"); + } + + @Test + @TestMetadata("defaultValueMustBeConstant.kt") + public void testDefaultValueMustBeConstant() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/defaultValueMustBeConstant.kt"); + } + + @Test + @TestMetadata("dontPropagateExact.kt") + public void testDontPropagateExact() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/dontPropagateExact.kt"); + } + + @Test + @TestMetadata("explicitMetadata.kt") + public void testExplicitMetadata() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/explicitMetadata.kt"); + } + + @Test + @TestMetadata("jvmRecordWithoutJdk15.kt") + public void testJvmRecordWithoutJdk15() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmRecordWithoutJdk15.kt"); + } + + @Test + @TestMetadata("JvmSyntheticOnDelegate.kt") + public void testJvmSyntheticOnDelegate() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/JvmSyntheticOnDelegate.kt"); + } + + @Test + @TestMetadata("multipleRepeatables.kt") + public void testMultipleRepeatables() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/multipleRepeatables.kt"); + } + + @Test + @TestMetadata("qualifiedCallValue.kt") + public void testQualifiedCallValue() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/qualifiedCallValue.kt"); + } + + @Test + @TestMetadata("strictfpOnClass.kt") + public void testStrictfpOnClass() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/strictfpOnClass.kt"); + } + + @Test + @TestMetadata("Synchronized.kt") + public void testSynchronized() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/Synchronized.kt"); + } + + @Test + @TestMetadata("SynchronizedOnInterfaceCompanionMember.kt") + public void testSynchronizedOnInterfaceCompanionMember() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/SynchronizedOnInterfaceCompanionMember.kt"); + } + + @Test + @TestMetadata("targetuse.kt") + public void testTargetuse() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/targetuse.kt"); + } + + @Test + @TestMetadata("throws.kt") + public void testThrows() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/throws.kt"); + } + + @Test + @TestMetadata("throwsByStarWinsBuiltin.kt") + public void testThrowsByStarWinsBuiltin() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/throwsByStarWinsBuiltin.kt"); + } + + @Test + @TestMetadata("TransientOnDelegate.kt") + public void testTransientOnDelegate() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/TransientOnDelegate.kt"); + } + + @Test + @TestMetadata("Volatile.kt") + public void testVolatile() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/Volatile.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability") + @TestDataPath("$PROJECT_ROOT") + public class AnnotationApplicability { + @Test + public void testAllFilesPresentInAnnotationApplicability() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("annotationsOnUseSiteTargets.kt") + public void testAnnotationsOnUseSiteTargets() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/annotationsOnUseSiteTargets.kt"); + } + + @Test + @TestMetadata("illegalPlatformName.kt") + public void testIllegalPlatformName() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/illegalPlatformName.kt"); + } + + @Test + @TestMetadata("jvmName.kt") + public void testJvmName() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/jvmName.kt"); + } + + @Test + @TestMetadata("jvmNameOnMangledNames.kt") + public void testJvmNameOnMangledNames() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/jvmNameOnMangledNames.kt"); + } + + @Test + @TestMetadata("multifileClassPart.kt") + public void testMultifileClassPart() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/multifileClassPart.kt"); + } + + @Test + @TestMetadata("multifileClassPartWithJavaAnnotation.kt") + public void testMultifileClassPartWithJavaAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/multifileClassPartWithJavaAnnotation.kt"); + } + + @Test + @TestMetadata("suppressOnFunctionReference.kt") + public void testSuppressOnFunctionReference() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/suppressOnFunctionReference.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant") + @TestDataPath("$PROJECT_ROOT") + public class AnnotationParameterMustBeConstant { + @Test + public void testAllFilesPresentInAnnotationParameterMustBeConstant() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("array.kt") + public void testArray() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/array.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/simple.kt"); + } + + @Test + @TestMetadata("useOfNonConstVal.kt") + public void testUseOfNonConstVal() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/useOfNonConstVal.kt"); + } + + @Test + @TestMetadata("vararg.kt") + public void testVararg() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/vararg.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters") + @TestDataPath("$PROJECT_ROOT") + public class AnnotationParameters { + @Test + public void testAllFilesPresentInAnnotationParameters() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("kt10136.kt") + public void testKt10136() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/kt10136.kt"); + } + + @Test + @TestMetadata("nonConstValAsArgument.kt") + public void testNonConstValAsArgument() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/nonConstValAsArgument.kt"); + } + + @Test + @TestMetadata("orderWithValue.kt") + public void testOrderWithValue() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/orderWithValue.kt"); + } + + @Test + @TestMetadata("orderWithoutValue.kt") + public void testOrderWithoutValue() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/orderWithoutValue.kt"); + } + + @Test + @TestMetadata("valueArray.kt") + public void testValueArray() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArray.kt"); + } + + @Test + @TestMetadata("valueArrayAndOtherDefault.kt") + public void testValueArrayAndOtherDefault() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayAndOtherDefault.kt"); + } + + @Test + @TestMetadata("valueArrayOnly.kt") + public void testValueArrayOnly() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayOnly.kt"); + } + + @Test + @TestMetadata("valueArrayWithDefault.kt") + public void testValueArrayWithDefault() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayWithDefault.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter") + @TestDataPath("$PROJECT_ROOT") + public class AnnotationWithVarargParameter { + @Test + public void testAllFilesPresentInAnnotationWithVarargParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("javaAnnotationWithVarargArgument.kt") + public void testJavaAnnotationWithVarargArgument() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/javaAnnotationWithVarargArgument.kt"); + } + + @Test + @TestMetadata("kotlinAnnotationWithVarargArgument.kt") + public void testKotlinAnnotationWithVarargArgument() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/kotlinAnnotationWithVarargArgument.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter") + @TestDataPath("$PROJECT_ROOT") + public class JavaAnnotationsWithKClassParameter { + @Test + public void testAllFilesPresentInJavaAnnotationsWithKClassParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("annotationAsArgument.kt") + public void testAnnotationAsArgument() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/annotationAsArgument.kt"); + } + + @Test + @TestMetadata("arg.kt") + public void testArg() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/arg.kt"); + } + + @Test + @TestMetadata("argAndOtherDefault.kt") + public void testArgAndOtherDefault() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argAndOtherDefault.kt"); + } + + @Test + @TestMetadata("argArray.kt") + public void testArgArray() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argArray.kt"); + } + + @Test + @TestMetadata("argWithDefault.kt") + public void testArgWithDefault() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argWithDefault.kt"); + } + + @Test + @TestMetadata("argWithDefaultAndOther.kt") + public void testArgWithDefaultAndOther() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argWithDefaultAndOther.kt"); + } + + @Test + @TestMetadata("twoArgs.kt") + public void testTwoArgs() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/twoArgs.kt"); + } + + @Test + @TestMetadata("value.kt") + public void testValue() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/value.kt"); + } + + @Test + @TestMetadata("valueAndOtherDefault.kt") + public void testValueAndOtherDefault() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueAndOtherDefault.kt"); + } + + @Test + @TestMetadata("valueArray.kt") + public void testValueArray() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueArray.kt"); + } + + @Test + @TestMetadata("valueWithDefault.kt") + public void testValueWithDefault() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueWithDefault.kt"); + } + + @Test + @TestMetadata("valueWithDefaultAndOther.kt") + public void testValueWithDefaultAndOther() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueWithDefaultAndOther.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault") + @TestDataPath("$PROJECT_ROOT") + public class JvmDefault { + @Test + public void testAllFilesPresentInJvmDefault() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("generic.kt") + public void testGeneric() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/generic.kt"); + } + + @Test + @TestMetadata("javaOverride.kt") + public void testJavaOverride() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/javaOverride.kt"); + } + + @Test + @TestMetadata("javaOverrideAll.kt") + public void testJavaOverrideAll() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/javaOverrideAll.kt"); + } + + @Test + @TestMetadata("jvmDefaultInInheritance.kt") + public void testJvmDefaultInInheritance() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultInInheritance.kt"); + } + + @Test + @TestMetadata("jvmDefaults.kt") + public void testJvmDefaults() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaults.kt"); + } + + @Test + @TestMetadata("jvmDefaultsWithJava.kt") + public void testJvmDefaultsWithJava() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultsWithJava.kt"); + } + + @Test + @TestMetadata("noJvmDefaultFlag.kt") + public void testNoJvmDefaultFlag() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/noJvmDefaultFlag.kt"); + } + + @Test + @TestMetadata("notInterface.kt") + public void testNotInterface() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/notInterface.kt"); + } + + @Test + @TestMetadata("propertyAccessor.kt") + public void testPropertyAccessor() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/propertyAccessor.kt"); + } + + @Test + @TestMetadata("simpleOverride.kt") + public void testSimpleOverride() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/simpleOverride.kt"); + } + + @Test + @TestMetadata("simplePropertyOverride.kt") + public void testSimplePropertyOverride() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/simplePropertyOverride.kt"); + } + + @Test + @TestMetadata("superCall.kt") + public void testSuperCall() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/superCall.kt"); + } + + @Test + @TestMetadata("superCallAmbiguity.kt") + public void testSuperCallAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/superCallAmbiguity.kt"); + } + + @Test + @TestMetadata("superCallAmbiguity2.kt") + public void testSuperCallAmbiguity2() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/superCallAmbiguity2.kt"); + } + + @Test + @TestMetadata("superCallAmbiguity3.kt") + public void testSuperCallAmbiguity3() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/superCallAmbiguity3.kt"); + } + + @Test + @TestMetadata("target6.kt") + public void testTarget6() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/target6.kt"); + } + + @Test + @TestMetadata("target8.kt") + public void testTarget8() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/target8.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/allCompatibility") + @TestDataPath("$PROJECT_ROOT") + public class AllCompatibility { + @Test + public void testAllFilesPresentInAllCompatibility() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("specialization.kt") + public void testSpecialization() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/allCompatibility/specialization.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultWithCompatibility") + @TestDataPath("$PROJECT_ROOT") + public class JvmDefaultWithCompatibility { + @Test + public void testAllFilesPresentInJvmDefaultWithCompatibility() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultWithCompatibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("target6.kt") + public void testTarget6() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultWithCompatibility/target6.kt"); + } + + @Test + @TestMetadata("target8.kt") + public void testTarget8() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultWithCompatibility/target8.kt"); + } + + @Test + @TestMetadata("target8Disabled.kt") + public void testTarget8Disabled() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultWithCompatibility/target8Disabled.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultWithoutCompatibility") + @TestDataPath("$PROJECT_ROOT") + public class JvmDefaultWithoutCompatibility { + @Test + public void testAllFilesPresentInJvmDefaultWithoutCompatibility() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultWithoutCompatibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("target6.kt") + public void testTarget6() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultWithoutCompatibility/target6.kt"); + } + + @Test + @TestMetadata("target8.kt") + public void testTarget8() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultWithoutCompatibility/target8.kt"); + } + + @Test + @TestMetadata("target8Disabled.kt") + public void testTarget8Disabled() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultWithoutCompatibility/target8Disabled.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField") + @TestDataPath("$PROJECT_ROOT") + public class JvmField { + @Test + public void testAllFilesPresentInJvmField() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("clashWithCompanionObjectField.kt") + public void testClashWithCompanionObjectField() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/clashWithCompanionObjectField.kt"); + } + + @Test + @TestMetadata("inMultiFileFacade.kt") + public void testInMultiFileFacade() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/inMultiFileFacade.kt"); + } + + @Test + @TestMetadata("inSingleFileFacade.kt") + public void testInSingleFileFacade() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/inSingleFileFacade.kt"); + } + + @Test + @TestMetadata("interface13.kt") + public void testInterface13() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/interface13.kt"); + } + + @Test + @TestMetadata("jvmFieldApplicability_1_5.kt") + public void testJvmFieldApplicability_1_5() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/jvmFieldApplicability_1_5.kt"); + } + + @Test + @TestMetadata("jvmFieldApplicability_1_6.kt") + public void testJvmFieldApplicability_1_6() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/jvmFieldApplicability_1_6.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads") + @TestDataPath("$PROJECT_ROOT") + public class JvmOverloads { + @Test + public void testAllFilesPresentInJvmOverloads() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("JvmOverloadWithNoDefaults.kt") + public void testJvmOverloadWithNoDefaults() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/JvmOverloadWithNoDefaults.kt"); + } + + @Test + @TestMetadata("jvmOverloadsOnAbstractMethods.kt") + public void testJvmOverloadsOnAbstractMethods() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAbstractMethods.kt"); + } + + @Test + @TestMetadata("jvmOverloadsOnAnnotationClassConstructor_1_3.kt") + public void testJvmOverloadsOnAnnotationClassConstructor_1_3() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAnnotationClassConstructor_1_3.kt"); + } + + @Test + @TestMetadata("jvmOverloadsOnAnnotationClassConstructor_1_4.kt") + public void testJvmOverloadsOnAnnotationClassConstructor_1_4() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAnnotationClassConstructor_1_4.kt"); + } + + @Test + @TestMetadata("jvmOverloadsOnMangledFunctions.kt") + public void testJvmOverloadsOnMangledFunctions() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnMangledFunctions.kt"); + } + + @Test + @TestMetadata("jvmOverloadsOnPrivate.kt") + public void testJvmOverloadsOnPrivate() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnPrivate.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmPackageName") + @TestDataPath("$PROJECT_ROOT") + public class JvmPackageName { + @Test + public void testAllFilesPresentInJvmPackageName() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("incorrectJvmPackageName.kt") + public void testIncorrectJvmPackageName() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmPackageName/incorrectJvmPackageName.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmSpecialFunctions") + @TestDataPath("$PROJECT_ROOT") + public class JvmSpecialFunctions { + @Test + public void testAllFilesPresentInJvmSpecialFunctions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmSpecialFunctions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("apiVersionIsAtLeastHasConstArguments.kt") + public void testApiVersionIsAtLeastHasConstArguments() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmSpecialFunctions/apiVersionIsAtLeastHasConstArguments.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic") + @TestDataPath("$PROJECT_ROOT") + public class JvmStatic { + @Test + public void testAllFilesPresentInJvmStatic() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("constOrJvmFieldProperty.kt") + public void testConstOrJvmFieldProperty() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/constOrJvmFieldProperty.kt"); + } + + @Test + @TestMetadata("constructorProperty.kt") + public void testConstructorProperty() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/constructorProperty.kt"); + } + + @Test + @TestMetadata("constructorProperty_LL13.kt") + public void testConstructorProperty_LL13() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/constructorProperty_LL13.kt"); + } + + @Test + @TestMetadata("constructors.kt") + public void testConstructors() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/constructors.kt"); + } + + @Test + @TestMetadata("finalAndAbstract.kt") + public void testFinalAndAbstract() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/finalAndAbstract.kt"); + } + + @Test + @TestMetadata("functions.kt") + public void testFunctions() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/functions.kt"); + } + + @Test + @TestMetadata("functions_LL13.kt") + public void testFunctions_LL13() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/functions_LL13.kt"); + } + + @Test + @TestMetadata("interfaceCompanion_LL12.kt") + public void testInterfaceCompanion_LL12() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/interfaceCompanion_LL12.kt"); + } + + @Test + @TestMetadata("interfaceCompanion_LL13_16.kt") + public void testInterfaceCompanion_LL13_16() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/interfaceCompanion_LL13_16.kt"); + } + + @Test + @TestMetadata("interfaceCompanion_LL13_18.kt") + public void testInterfaceCompanion_LL13_18() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/interfaceCompanion_LL13_18.kt"); + } + + @Test + @TestMetadata("localFun.kt") + public void testLocalFun() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/localFun.kt"); + } + + @Test + @TestMetadata("localFun_LL13.kt") + public void testLocalFun_LL13() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/localFun_LL13.kt"); + } + + @Test + @TestMetadata("mainInObject.kt") + public void testMainInObject() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/mainInObject.kt"); + } + + @Test + @TestMetadata("privateCompanionObject.kt") + public void testPrivateCompanionObject() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/privateCompanionObject.kt"); + } + + @Test + @TestMetadata("property.kt") + public void testProperty() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/property.kt"); + } + + @Test + @TestMetadata("property_LL13.kt") + public void testProperty_LL13() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/property_LL13.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass") + @TestDataPath("$PROJECT_ROOT") + public class KClass { + @Test + public void testAllFilesPresentInKClass() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("kClassArrayInAnnotationsInVariance.kt") + public void testKClassArrayInAnnotationsInVariance() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsInVariance.kt"); + } + + @Test + @TestMetadata("kClassArrayInAnnotationsOutVariance.kt") + public void testKClassArrayInAnnotationsOutVariance() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsOutVariance.kt"); + } + + @Test + @TestMetadata("kClassInAnnotation.kt") + public void testKClassInAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotation.kt"); + } + + @Test + @TestMetadata("kClassInAnnotationsInVariance.kt") + public void testKClassInAnnotationsInVariance() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsInVariance.kt"); + } + + @Test + @TestMetadata("kClassInAnnotationsOutVariance.kt") + public void testKClassInAnnotationsOutVariance() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsOutVariance.kt"); + } + + @Test + @TestMetadata("kClassInvariantTP.kt") + public void testKClassInvariantTP() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInvariantTP.kt"); + } + + @Test + @TestMetadata("kClassOutArrayInAnnotationsOutVariance.kt") + public void testKClassOutArrayInAnnotationsOutVariance() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassOutArrayInAnnotationsOutVariance.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument") + @TestDataPath("$PROJECT_ROOT") + public class ProhibitPositionedArgument { + @Test + public void testAllFilesPresentInProhibitPositionedArgument() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("kotlinAnnotation.kt") + public void testKotlinAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/kotlinAnnotation.kt"); + } + + @Test + @TestMetadata("tooManyArgs.kt") + public void testTooManyArgs() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/tooManyArgs.kt"); + } + + @Test + @TestMetadata("typeMismatch.kt") + public void testTypeMismatch() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/typeMismatch.kt"); + } + + @Test + @TestMetadata("withValue.kt") + public void testWithValue() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/withValue.kt"); + } + + @Test + @TestMetadata("withoutValue.kt") + public void testWithoutValue() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/withoutValue.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/assert") + @TestDataPath("$PROJECT_ROOT") + public class Assert { + @Test + public void testAllFilesPresentInAssert() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/assert"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("cast.kt") + public void testCast() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/assert/cast.kt"); + } + + @Test + @TestMetadata("safeCall.kt") + public void testSafeCall() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/assert/safeCall.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/builderInference") + @TestDataPath("$PROJECT_ROOT") + public class BuilderInference { + @Test + public void testAllFilesPresentInBuilderInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/builderInference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("buildListToUpperBound.kt") + public void testBuildListToUpperBound() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/builderInference/buildListToUpperBound.kt"); + } + + @Test + @TestMetadata("buildListToUpperBoundForbidden.kt") + public void testBuildListToUpperBoundForbidden() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/builderInference/buildListToUpperBoundForbidden.kt"); + } + + @Test + @TestMetadata("buildListToUpperBoundInLazy.kt") + public void testBuildListToUpperBoundInLazy() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/builderInference/buildListToUpperBoundInLazy.kt"); + } + + @Test + @TestMetadata("buildListToUpperBoundInLazyForbidden.kt") + public void testBuildListToUpperBoundInLazyForbidden() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/builderInference/buildListToUpperBoundInLazyForbidden.kt"); + } + + @Test + @TestMetadata("completeIrrelevantCalls.kt") + public void testCompleteIrrelevantCalls() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/builderInference/completeIrrelevantCalls.kt"); + } + + @Test + @TestMetadata("incorrectCalls.kt") + public void testIncorrectCalls() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/builderInference/incorrectCalls.kt"); + } + + @Test + @TestMetadata("incorrectCallsWithRestrictions.kt") + public void testIncorrectCallsWithRestrictions() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/builderInference/incorrectCallsWithRestrictions.kt"); + } + + @Test + @TestMetadata("inferCoroutineTypeInOldVersion.kt") + public void testInferCoroutineTypeInOldVersion() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/builderInference/inferCoroutineTypeInOldVersion.kt"); + } + + @Test + @TestMetadata("resolveUsualCallWithBuilderInference.kt") + public void testResolveUsualCallWithBuilderInference() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/builderInference/resolveUsualCallWithBuilderInference.kt"); + } + + @Test + @TestMetadata("resolveUsualCallWithBuilderInferenceWithRestrictions.kt") + public void testResolveUsualCallWithBuilderInferenceWithRestrictions() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/builderInference/resolveUsualCallWithBuilderInferenceWithRestrictions.kt"); + } + + @Test + @TestMetadata("typeVariableShouldNotBeFixed.kt") + public void testTypeVariableShouldNotBeFixed() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/builderInference/typeVariableShouldNotBeFixed.kt"); + } + + @Test + @TestMetadata("unsafeAssignment.kt") + public void testUnsafeAssignment() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/builderInference/unsafeAssignment.kt"); + } + + @Test + @TestMetadata("unsafeAssignmentExtra.kt") + public void testUnsafeAssignmentExtra() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/builderInference/unsafeAssignmentExtra.kt"); + } + + @Test + @TestMetadata("unsafeAssignment_noReport.kt") + public void testUnsafeAssignment_noReport() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/builderInference/unsafeAssignment_noReport.kt"); + } + + @Test + @TestMetadata("useInferenceInformationFromExtension.kt") + public void testUseInferenceInformationFromExtension() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/builderInference/useInferenceInformationFromExtension.kt"); + } + + @Test + @TestMetadata("useInferenceInformationFromExtensionWithRestrictions.kt") + public void testUseInferenceInformationFromExtensionWithRestrictions() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/builderInference/useInferenceInformationFromExtensionWithRestrictions.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/builtins") + @TestDataPath("$PROJECT_ROOT") + public class Builtins { + @Test + public void testAllFilesPresentInBuiltins() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/builtins"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("arraysAreCloneable.kt") + public void testArraysAreCloneable() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/builtins/arraysAreCloneable.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/cast") + @TestDataPath("$PROJECT_ROOT") + public class Cast { + @Test + public void testAllFilesPresentInCast() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/cast"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("AsInsideIn.kt") + public void testAsInsideIn() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/cast/AsInsideIn.kt"); + } + + @Test + @TestMetadata("IsArray.kt") + public void testIsArray() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/cast/IsArray.kt"); + } + + @Test + @TestMetadata("IsReified.kt") + public void testIsReified() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/cast/IsReified.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts") + @TestDataPath("$PROJECT_ROOT") + public class Contracts { + @Test + public void testAllFilesPresentInContracts() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow") + @TestDataPath("$PROJECT_ROOT") + public class Controlflow { + @Test + public void testAllFilesPresentInControlflow() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining") + @TestDataPath("$PROJECT_ROOT") + public class FlowInlining { + @Test + public void testAllFilesPresentInFlowInlining() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("breakContinuesInInlinedLambda.kt") + public void testBreakContinuesInInlinedLambda() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/breakContinuesInInlinedLambda.kt"); + } + + @Test + @TestMetadata("expressionBody.kt") + public void testExpressionBody() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/expressionBody.kt"); + } + + @Test + @TestMetadata("implicitCastToAnyInReturnType.kt") + public void testImplicitCastToAnyInReturnType() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/implicitCastToAnyInReturnType.kt"); + } + + @Test + @TestMetadata("inlinedLambdaAlwaysThrows.kt") + public void testInlinedLambdaAlwaysThrows() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/inlinedLambdaAlwaysThrows.kt"); + } + + @Test + @TestMetadata("irrelevantUnknownClosure.kt") + public void testIrrelevantUnknownClosure() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/irrelevantUnknownClosure.kt"); + } + + @Test + @TestMetadata("labeledReturns.kt") + public void testLabeledReturns() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/labeledReturns.kt"); + } + + @Test + @TestMetadata("nestedTryCatchFinally.kt") + public void testNestedTryCatchFinally() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/nestedTryCatchFinally.kt"); + } + + @Test + @TestMetadata("nestedTryCatchs.kt") + public void testNestedTryCatchs() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/nestedTryCatchs.kt"); + } + + @Test + @TestMetadata("nonLocalReturn.kt") + public void testNonLocalReturn() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/nonLocalReturn.kt"); + } + + @Test + @TestMetadata("nonReturningInlinedLambda.kt") + public void testNonReturningInlinedLambda() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/nonReturningInlinedLambda.kt"); + } + + @Test + @TestMetadata("safeCallAndInPlaceReturn.kt") + public void testSafeCallAndInPlaceReturn() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/safeCallAndInPlaceReturn.kt"); + } + + @Test + @TestMetadata("severalJumpOutsFromInlinedLambda.kt") + public void testSeveralJumpOutsFromInlinedLambda() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/severalJumpOutsFromInlinedLambda.kt"); + } + + @Test + @TestMetadata("throwIfNotCalled.kt") + public void testThrowIfNotCalled() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/throwIfNotCalled.kt"); + } + + @Test + @TestMetadata("tryCatch.kt") + public void testTryCatch() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/tryCatch.kt"); + } + + @Test + @TestMetadata("tryCatchFinally.kt") + public void testTryCatchFinally() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/tryCatchFinally.kt"); + } + + @Test + @TestMetadata("typeMismatch.kt") + public void testTypeMismatch() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/typeMismatch.kt"); + } + + @Test + @TestMetadata("unreachableCode.kt") + public void testUnreachableCode() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/unreachableCode.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization") + @TestDataPath("$PROJECT_ROOT") + public class Initialization { + @Test + public void testAllFilesPresentInInitialization() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/atLeastOnce") + @TestDataPath("$PROJECT_ROOT") + public class AtLeastOnce { + @Test + public void testAllFilesPresentInAtLeastOnce() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/atLeastOnce"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("valDefiniteReassignment.kt") + public void testValDefiniteReassignment() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/atLeastOnce/valDefiniteReassignment.kt"); + } + + @Test + @TestMetadata("varDefiniteInitialization.kt") + public void testVarDefiniteInitialization() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/atLeastOnce/varDefiniteInitialization.kt"); + } + + @Test + @TestMetadata("varIndefiniteInitialization.kt") + public void testVarIndefiniteInitialization() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/atLeastOnce/varIndefiniteInitialization.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce") + @TestDataPath("$PROJECT_ROOT") + public class ExactlyOnce { + @Test + public void testAllFilesPresentInExactlyOnce() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("valDefiniteInitialization.kt") + public void testValDefiniteInitialization() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce/valDefiniteInitialization.kt"); + } + + @Test + @TestMetadata("valDefiniteReassignment.kt") + public void testValDefiniteReassignment() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce/valDefiniteReassignment.kt"); + } + + @Test + @TestMetadata("valIndefiniteInitialization.kt") + public void testValIndefiniteInitialization() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce/valIndefiniteInitialization.kt"); + } + + @Test + @TestMetadata("varDefiniteInitalization.kt") + public void testVarDefiniteInitalization() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce/varDefiniteInitalization.kt"); + } + + @Test + @TestMetadata("varIndefiniteInitialization.kt") + public void testVarIndefiniteInitialization() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce/varIndefiniteInitialization.kt"); + } + + @Test + @TestMetadata("withReceiver.kt") + public void testWithReceiver() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce/withReceiver.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/unknown") + @TestDataPath("$PROJECT_ROOT") + public class Unknown { + @Test + public void testAllFilesPresentInUnknown() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/unknown"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("unknownInvocations.kt") + public void testUnknownInvocations() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/unknown/unknownInvocations.kt"); + } + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl") + @TestDataPath("$PROJECT_ROOT") + public class Dsl { + @Test + public void testAllFilesPresentInDsl() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("callUsualContractFunction.kt") + public void testCallUsualContractFunction() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/callUsualContractFunction.kt"); + } + + @Test + @TestMetadata("fqnContractFunction.kt") + public void testFqnContractFunction() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/fqnContractFunction.kt"); + } + + @Test + @TestMetadata("rewriteAtSliceFunctor.kt") + public void testRewriteAtSliceFunctor() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/rewriteAtSliceFunctor.kt"); + } + + @Test + @TestMetadata("useBeforeDeclaration.kt") + public void testUseBeforeDeclaration() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/useBeforeDeclaration.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors") + @TestDataPath("$PROJECT_ROOT") + public class Errors { + @Test + @TestMetadata("accessToOuterThis.kt") + public void testAccessToOuterThis() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/accessToOuterThis.kt"); + } + + @Test + public void testAllFilesPresentInErrors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("booleanComparisons.kt") + public void testBooleanComparisons() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/booleanComparisons.kt"); + } + + @Test + @TestMetadata("callInContractDescription.kt") + public void testCallInContractDescription() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/callInContractDescription.kt"); + } + + @Test + @TestMetadata("contractCallSites.1.3.kt") + public void testContractCallSites_1_3() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/contractCallSites.1.3.kt"); + } + + @Test + @TestMetadata("contractCallSites.1.4.kt") + public void testContractCallSites_1_4() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/contractCallSites.1.4.kt"); + } + + @Test + @TestMetadata("emptyContract.kt") + public void testEmptyContract() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/emptyContract.kt"); + } + + @Test + @TestMetadata("illegalConstructionInContractBlock.kt") + public void testIllegalConstructionInContractBlock() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/illegalConstructionInContractBlock.kt"); + } + + @Test + @TestMetadata("illegalEqualsCondition.kt") + public void testIllegalEqualsCondition() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/illegalEqualsCondition.kt"); + } + + @Test + @TestMetadata("nestedConditionalEffects.kt") + public void testNestedConditionalEffects() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/nestedConditionalEffects.kt"); + } + + @Test + @TestMetadata("nonLambdaLiteralAsArgument.kt") + public void testNonLambdaLiteralAsArgument() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/nonLambdaLiteralAsArgument.kt"); + } + + @Test + @TestMetadata("notFirstStatement.kt") + public void testNotFirstStatement() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/notFirstStatement.kt"); + } + + @Test + @TestMetadata("recursiveContract.kt") + public void testRecursiveContract() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/recursiveContract.kt"); + } + + @Test + @TestMetadata("recursiveContractCustomContractFunction.kt") + public void testRecursiveContractCustomContractFunction() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/recursiveContractCustomContractFunction.kt"); + } + + @Test + @TestMetadata("referenceToProperty.1.3.kt") + public void testReferenceToProperty_1_3() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/referenceToProperty.1.3.kt"); + } + + @Test + @TestMetadata("referenceToProperty.1.4.kt") + public void testReferenceToProperty_1_4() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/referenceToProperty.1.4.kt"); + } + + @Test + @TestMetadata("typeReferences.1.3.kt") + public void testTypeReferences_1_3() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/typeReferences.1.3.kt"); + } + + @Test + @TestMetadata("typeReferences.1.4.kt") + public void testTypeReferences_1_4() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/typeReferences.1.4.kt"); + } + + @Test + @TestMetadata("unlabeledReceiver.kt") + public void testUnlabeledReceiver() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/unlabeledReceiver.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/fromStdlib") + @TestDataPath("$PROJECT_ROOT") + public class FromStdlib { + @Test + public void testAllFilesPresentInFromStdlib() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/fromStdlib"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("check.kt") + public void testCheck() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/fromStdlib/check.kt"); + } + + @Test + @TestMetadata("fromStandardKt.kt") + public void testFromStandardKt() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/fromStdlib/fromStandardKt.kt"); + } + + @Test + @TestMetadata("isNullOrBlank.kt") + public void testIsNullOrBlank() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/fromStdlib/isNullOrBlank.kt"); + } + + @Test + @TestMetadata("isNullOrEmpty.kt") + public void testIsNullOrEmpty() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/fromStdlib/isNullOrEmpty.kt"); + } + + @Test + @TestMetadata("kt45243.kt") + public void testKt45243() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/fromStdlib/kt45243.kt"); + } + + @Test + @TestMetadata("require.kt") + public void testRequire() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/fromStdlib/require.kt"); + } + + @Test + @TestMetadata("synchronize.kt") + public void testSynchronize() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/fromStdlib/synchronize.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/newSyntax") + @TestDataPath("$PROJECT_ROOT") + public class NewSyntax { + @Test + public void testAllFilesPresentInNewSyntax() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/newSyntax"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("complexContractDescription.kt") + public void testComplexContractDescription() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/newSyntax/complexContractDescription.kt"); + } + + @Test + @TestMetadata("onelineFunctionsContractDescription.kt") + public void testOnelineFunctionsContractDescription() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/newSyntax/onelineFunctionsContractDescription.kt"); + } + + @Test + @TestMetadata("propertyAccessorsContractDescription.kt") + public void testPropertyAccessorsContractDescription() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/newSyntax/propertyAccessorsContractDescription.kt"); + } + + @Test + @TestMetadata("simpleFunctionsContractDescription.kt") + public void testSimpleFunctionsContractDescription() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/newSyntax/simpleFunctionsContractDescription.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts") + @TestDataPath("$PROJECT_ROOT") + public class Smartcasts { + @Test + public void testAllFilesPresentInSmartcasts() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("callWithDefaultValue.kt") + public void testCallWithDefaultValue() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/callWithDefaultValue.kt"); + } + + @Test + @TestMetadata("catchExceptionSpilling.kt") + public void testCatchExceptionSpilling() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/catchExceptionSpilling.kt"); + } + + @Test + @TestMetadata("compositions.kt") + public void testCompositions() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/compositions.kt"); + } + + @Test + @TestMetadata("contractWithDeepGenerics.kt") + public void testContractWithDeepGenerics() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/contractWithDeepGenerics.kt"); + } + + @Test + @TestMetadata("contractsOnMembers.kt") + public void testContractsOnMembers() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/contractsOnMembers.kt"); + } + + @Test + @TestMetadata("deeplyNested.kt") + public void testDeeplyNested() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/deeplyNested.kt"); + } + + @Test + @TestMetadata("extensionReceiver.kt") + public void testExtensionReceiver() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/extensionReceiver.kt"); + } + + @Test + @TestMetadata("extensionReceiver_after.kt") + public void testExtensionReceiver_after() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/extensionReceiver_after.kt"); + } + + @Test + @TestMetadata("externalArguments.kt") + public void testExternalArguments() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/externalArguments.kt"); + } + + @Test + @TestMetadata("functionInCompanion.kt") + public void testFunctionInCompanion() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/functionInCompanion.kt"); + } + + @Test + @TestMetadata("intersectingInfo.kt") + public void testIntersectingInfo() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/intersectingInfo.kt"); + } + + @Test + @TestMetadata("intersectionTypes.kt") + public void testIntersectionTypes() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/intersectionTypes.kt"); + } + + @Test + @TestMetadata("nullabilitySmartcastWhenNullability.kt") + public void testNullabilitySmartcastWhenNullability() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/nullabilitySmartcastWhenNullability.kt"); + } + + @Test + @TestMetadata("partiallyIncorrect.kt") + public void testPartiallyIncorrect() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/partiallyIncorrect.kt"); + } + + @Test + @TestMetadata("receiver.kt") + public void testReceiver() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/receiver.kt"); + } + + @Test + @TestMetadata("reifiedGeneric.kt") + public void testReifiedGeneric() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/reifiedGeneric.kt"); + } + + @Test + @TestMetadata("safecallAndReturnsNull.kt") + public void testSafecallAndReturnsNull() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/safecallAndReturnsNull.kt"); + } + + @Test + @TestMetadata("throwsEffect.kt") + public void testThrowsEffect() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/throwsEffect.kt"); + } + + @Test + @TestMetadata("typeSmartcastWhenNullability.kt") + public void testTypeSmartcastWhenNullability() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/typeSmartcastWhenNullability.kt"); + } + + @Test + @TestMetadata("unreachableBranches.kt") + public void testUnreachableBranches() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/unreachableBranches.kt"); + } + + @Test + @TestMetadata("valueOfContractedFunctionIngored.kt") + public void testValueOfContractedFunctionIngored() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/valueOfContractedFunctionIngored.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/multieffect") + @TestDataPath("$PROJECT_ROOT") + public class Multieffect { + @Test + public void testAllFilesPresentInMultieffect() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/multieffect"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("implicitIff.kt") + public void testImplicitIff() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/multieffect/implicitIff.kt"); + } + + @Test + @TestMetadata("returnsAndCalls.kt") + public void testReturnsAndCalls() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/multieffect/returnsAndCalls.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests") + @TestDataPath("$PROJECT_ROOT") + public class OperatorsTests { + @Test + public void testAllFilesPresentInOperatorsTests() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("andOperator.kt") + public void testAndOperator() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/andOperator.kt"); + } + + @Test + @TestMetadata("andOperatorWithConstant.kt") + public void testAndOperatorWithConstant() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/andOperatorWithConstant.kt"); + } + + @Test + @TestMetadata("andOperatorWithUnknown.kt") + public void testAndOperatorWithUnknown() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/andOperatorWithUnknown.kt"); + } + + @Test + @TestMetadata("equalsOperator.kt") + public void testEqualsOperator() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/equalsOperator.kt"); + } + + @Test + @TestMetadata("equalsWithNullableBoolean.kt") + public void testEqualsWithNullableBoolean() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/equalsWithNullableBoolean.kt"); + } + + @Test + @TestMetadata("isInstanceOperator.kt") + public void testIsInstanceOperator() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/isInstanceOperator.kt"); + } + + @Test + @TestMetadata("orOperator.kt") + public void testOrOperator() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/orOperator.kt"); + } + + @Test + @TestMetadata("orOperatorWithConstant.kt") + public void testOrOperatorWithConstant() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/orOperatorWithConstant.kt"); + } + + @Test + @TestMetadata("orOperatorWithUnknown.kt") + public void testOrOperatorWithUnknown() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/orOperatorWithUnknown.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/when") + @TestDataPath("$PROJECT_ROOT") + public class When { + @Test + public void testAllFilesPresentInWhen() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/when"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("kt36818.kt") + public void testKt36818() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/when/kt36818.kt"); + } + + @Test + @TestMetadata("withSubject.kt") + public void testWithSubject() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/when/withSubject.kt"); + } + + @Test + @TestMetadata("withSubjectNullableBoolean.kt") + public void testWithSubjectNullableBoolean() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/when/withSubjectNullableBoolean.kt"); + } + + @Test + @TestMetadata("withoutSubject.kt") + public void testWithoutSubject() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/when/withoutSubject.kt"); + } + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines") + @TestDataPath("$PROJECT_ROOT") + public class Coroutines { + @Test + public void testAllFilesPresentInCoroutines() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("allowNullOperatorsForResult_1_3.kt") + public void testAllowNullOperatorsForResult_1_3() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/allowNullOperatorsForResult_1_3.kt"); + } + + @Test + @TestMetadata("allowNullOperatorsForResult_1_4.kt") + public void testAllowNullOperatorsForResult_1_4() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/allowNullOperatorsForResult_1_4.kt"); + } + + @Test + @TestMetadata("allowResultInReturnTypeWithFlag.kt") + public void testAllowResultInReturnTypeWithFlag() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/allowResultInReturnTypeWithFlag.kt"); + } + + @Test + @TestMetadata("allowResultInReturnType_1_3.kt") + public void testAllowResultInReturnType_1_3() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/allowResultInReturnType_1_3.kt"); + } + + @Test + @TestMetadata("allowResultInReturnType_1_4.kt") + public void testAllowResultInReturnType_1_4() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/allowResultInReturnType_1_4.kt"); + } + + @Test + @TestMetadata("basicBuildListBuildMap.kt") + public void testBasicBuildListBuildMap() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/basicBuildListBuildMap.kt"); + } + + @Test + @TestMetadata("callableReferences.kt") + public void testCallableReferences() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReferences.kt"); + } + + @Test + @TestMetadata("coroutineContext.kt") + public void testCoroutineContext() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/coroutineContext.kt"); + } + + @Test + @TestMetadata("illegalSuspendCalls.kt") + public void testIllegalSuspendCalls() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/illegalSuspendCalls.kt"); + } + + @Test + @TestMetadata("illegalSuspendCallsForDelegated.kt") + public void testIllegalSuspendCallsForDelegated() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/illegalSuspendCallsForDelegated.kt"); + } + + @Test + @TestMetadata("irrelevantSuspendDeclarations.kt") + public void testIrrelevantSuspendDeclarations() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/irrelevantSuspendDeclarations.kt"); + } + + @Test + @TestMetadata("kSuspendFunctionAsSupertype.kt") + public void testKSuspendFunctionAsSupertype() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/kSuspendFunctionAsSupertype.kt"); + } + + @Test + @TestMetadata("kt18292.kt") + public void testKt18292() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/kt18292.kt"); + } + + @Test + @TestMetadata("kt28658.kt") + public void testKt28658() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/kt28658.kt"); + } + + @Test + @TestMetadata("kt36947.kt") + public void testKt36947() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/kt36947.kt"); + } + + @Test + @TestMetadata("kt37309.kt") + public void testKt37309() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/kt37309.kt"); + } + + @Test + @TestMetadata("kt38179.kt") + public void testKt38179() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/kt38179.kt"); + } + + @Test + @TestMetadata("kt41430.kt") + public void testKt41430() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/kt41430.kt"); + } + + @Test + @TestMetadata("lambdaExpectedType.kt") + public void testLambdaExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/lambdaExpectedType.kt"); + } + + @Test + @TestMetadata("mixingSuspendability.kt") + public void testMixingSuspendability() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/mixingSuspendability.kt"); + } + + @Test + @TestMetadata("modifierFormForNonBuiltInSuspend.kt") + public void testModifierFormForNonBuiltInSuspend() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/modifierFormForNonBuiltInSuspend.kt"); + } + + @Test + @TestMetadata("modifierFormForNonBuiltInSuspendWithAnyParameter.kt") + public void testModifierFormForNonBuiltInSuspendWithAnyParameter() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/modifierFormForNonBuiltInSuspendWithAnyParameter.kt"); + } + + @Test + @TestMetadata("noDefaultCoroutineImports.kt") + public void testNoDefaultCoroutineImports() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/noDefaultCoroutineImports.kt"); + } + + @Test + @TestMetadata("nonLocalSuspension.kt") + public void testNonLocalSuspension() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/nonLocalSuspension.kt"); + } + + @Test + @TestMetadata("nonModifierFormForBuiltIn.kt") + public void testNonModifierFormForBuiltIn() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/nonModifierFormForBuiltIn.kt"); + } + + @Test + @TestMetadata("nonModifierFormForBuiltInRenameOnImport.kt") + public void testNonModifierFormForBuiltInRenameOnImport() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/nonModifierFormForBuiltInRenameOnImport.kt"); + } + + @Test + @TestMetadata("nonModifierFormForBuiltInWithFun.kt") + public void testNonModifierFormForBuiltInWithFun() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/nonModifierFormForBuiltInWithFun.kt"); + } + + @Test + @TestMetadata("operators.kt") + public void testOperators() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/operators.kt"); + } + + @Test + @TestMetadata("returnLabelForBuiltInSuspend.kt") + public void testReturnLabelForBuiltInSuspend() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/returnLabelForBuiltInSuspend.kt"); + } + + @Test + @TestMetadata("suspendApplicability.kt") + public void testSuspendApplicability() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendApplicability.kt"); + } + + @Test + @TestMetadata("suspendConflictsWithNoSuspend.kt") + public void testSuspendConflictsWithNoSuspend() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendConflictsWithNoSuspend.kt"); + } + + @Test + @TestMetadata("suspendCoroutineOrReturn.kt") + public void testSuspendCoroutineOrReturn() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineOrReturn.kt"); + } + + @Test + @TestMetadata("suspendCovarianJavaOverride.kt") + public void testSuspendCovarianJavaOverride() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCovarianJavaOverride.kt"); + } + + @Test + @TestMetadata("suspendDestructuring.kt") + public void testSuspendDestructuring() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendDestructuring.kt"); + } + + @Test + @TestMetadata("suspendExternalFunctions.kt") + public void testSuspendExternalFunctions() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendExternalFunctions.kt"); + } + + @Test + @TestMetadata("suspendFunctionN.kt") + public void testSuspendFunctionN() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionN.kt"); + } + + @Test + @TestMetadata("suspendFunctions.kt") + public void testSuspendFunctions() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctions.kt"); + } + + @Test + @TestMetadata("suspendJavaImplementationFromDifferentClass.kt") + public void testSuspendJavaImplementationFromDifferentClass() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendJavaImplementationFromDifferentClass.kt"); + } + + @Test + @TestMetadata("suspendJavaOverrides.kt") + public void testSuspendJavaOverrides() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendJavaOverrides.kt"); + } + + @Test + @TestMetadata("suspendLambda.kt") + public void testSuspendLambda() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendLambda.kt"); + } + + @Test + @TestMetadata("suspendOverridability.kt") + public void testSuspendOverridability() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendOverridability.kt"); + } + + @Test + @TestMetadata("suspendTest.kt") + public void testSuspendTest() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendTest.kt"); + } + + @Test + @TestMetadata("suspensionPointInMonitor.kt") + public void testSuspensionPointInMonitor() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspensionPointInMonitor.kt"); + } + + @Test + @TestMetadata("suspensionPointInMonitorNewInf.kt") + public void testSuspensionPointInMonitorNewInf() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspensionPointInMonitorNewInf.kt"); + } + + @Test + @TestMetadata("suspesionInDefaultValue.kt") + public void testSuspesionInDefaultValue() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspesionInDefaultValue.kt"); + } + + @Test + @TestMetadata("synchronizedOnSuspend.kt") + public void testSynchronizedOnSuspend() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/synchronizedOnSuspend.kt"); + } + + @Test + @TestMetadata("synchronizedOnSuspendError.kt") + public void testSynchronizedOnSuspendError() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/synchronizedOnSuspendError.kt"); + } + + @Test + @TestMetadata("tryCatchLambda.kt") + public void testTryCatchLambda() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/tryCatchLambda.kt"); + } + + @Test + @TestMetadata("usageOfResultTypeInReturnType.kt") + public void testUsageOfResultTypeInReturnType() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/usageOfResultTypeInReturnType.kt"); + } + + @Test + @TestMetadata("usageOfResultTypeInReturnType_1_4.kt") + public void testUsageOfResultTypeInReturnType_1_4() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/usageOfResultTypeInReturnType_1_4.kt"); + } + + @Test + @TestMetadata("usageOfResultTypeWithNullableOperators.kt") + public void testUsageOfResultTypeWithNullableOperators() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/usageOfResultTypeWithNullableOperators.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReference") + @TestDataPath("$PROJECT_ROOT") + public class CallableReference { + @Test + public void testAllFilesPresentInCallableReference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("bigArity.kt") + public void testBigArity() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReference/bigArity.kt"); + } + + @Test + @TestMetadata("callableReferenceOnUnresolvedLHS.kt") + public void testCallableReferenceOnUnresolvedLHS() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReference/callableReferenceOnUnresolvedLHS.kt"); + } + + @Test + @TestMetadata("property.kt") + public void testProperty() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReference/property.kt"); + } + + @Test + @TestMetadata("suspendConversionForCallableReferences.kt") + public void testSuspendConversionForCallableReferences() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReference/suspendConversionForCallableReferences.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference") + @TestDataPath("$PROJECT_ROOT") + public class Inference { + @Test + public void testAllFilesPresentInInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("applyInsideCoroutine.kt") + public void testApplyInsideCoroutine() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/applyInsideCoroutine.kt"); + } + + @Test + @TestMetadata("builderInferenceForMaterializeWithExpectedType.kt") + public void testBuilderInferenceForMaterializeWithExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/builderInferenceForMaterializeWithExpectedType.kt"); + } + + @Test + @TestMetadata("callableReferenceAndCoercionToUnit.kt") + public void testCallableReferenceAndCoercionToUnit() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/callableReferenceAndCoercionToUnit.kt"); + } + + @Test + @TestMetadata("callableReferenceToASuspendFunction.kt") + public void testCallableReferenceToASuspendFunction() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/callableReferenceToASuspendFunction.kt"); + } + + @Test + @TestMetadata("chainCallWithExtensionExplicitTypes.kt") + public void testChainCallWithExtensionExplicitTypes() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/chainCallWithExtensionExplicitTypes.kt"); + } + + @Test + @TestMetadata("coroutineInferenceWithCapturedTypeVariable.kt") + public void testCoroutineInferenceWithCapturedTypeVariable() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/coroutineInferenceWithCapturedTypeVariable.kt"); + } + + @Test + @TestMetadata("correctMember.kt") + public void testCorrectMember() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/correctMember.kt"); + } + + @Test + @TestMetadata("doubleColonExpressionToClassWithParameters.kt") + public void testDoubleColonExpressionToClassWithParameters() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/doubleColonExpressionToClassWithParameters.kt"); + } + + @Test + @TestMetadata("elvisOperatorAgainstFlexibleType.kt") + public void testElvisOperatorAgainstFlexibleType() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/elvisOperatorAgainstFlexibleType.kt"); + } + + @Test + @TestMetadata("extensionPriority.kt") + public void testExtensionPriority() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionPriority.kt"); + } + + @Test + @TestMetadata("extensionSuspend.kt") + public void testExtensionSuspend() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionSuspend.kt"); + } + + @Test + @TestMetadata("extensionWithNonValuableConstraints.kt") + public void testExtensionWithNonValuableConstraints() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionWithNonValuableConstraints.kt"); + } + + @Test + @TestMetadata("extensionsWithNonValuableConstraintsGenericBase.kt") + public void testExtensionsWithNonValuableConstraintsGenericBase() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionsWithNonValuableConstraintsGenericBase.kt"); + } + + @Test + @TestMetadata("extensionsWithNonValuableConstraints_1_2.kt") + public void testExtensionsWithNonValuableConstraints_1_2() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionsWithNonValuableConstraints_1_2.kt"); + } + + @Test + @TestMetadata("inferenceFromMethodInsideLocalVariable.kt") + public void testInferenceFromMethodInsideLocalVariable() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/inferenceFromMethodInsideLocalVariable.kt"); + } + + @Test + @TestMetadata("kt15516.kt") + public void testKt15516() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt15516.kt"); + } + + @Test + @TestMetadata("kt32097.kt") + public void testKt32097() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt32097.kt"); + } + + @Test + @TestMetadata("kt32203.kt") + public void testKt32203() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt32203.kt"); + } + + @Test + @TestMetadata("kt32271.kt") + public void testKt32271() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt32271.kt"); + } + + @Test + @TestMetadata("kt33542.kt") + public void testKt33542() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt33542.kt"); + } + + @Test + @TestMetadata("kt35306.kt") + public void testKt35306() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt35306.kt"); + } + + @Test + @TestMetadata("kt35684.kt") + public void testKt35684() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt35684.kt"); + } + + @Test + @TestMetadata("kt36202.kt") + public void testKt36202() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt36202.kt"); + } + + @Test + @TestMetadata("kt36220.kt") + public void testKt36220() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt36220.kt"); + } + + @Test + @TestMetadata("kt38420.kt") + public void testKt38420() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt38420.kt"); + } + + @Test + @TestMetadata("kt38667.kt") + public void testKt38667() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt38667.kt"); + } + + @Test + @TestMetadata("kt38766.kt") + public void testKt38766() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt38766.kt"); + } + + @Test + @TestMetadata("kt41164.kt") + public void testKt41164() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt41164.kt"); + } + + @Test + @TestMetadata("kt41308.kt") + public void testKt41308() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt41308.kt"); + } + + @Test + @TestMetadata("kt41396.kt") + public void testKt41396() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt41396.kt"); + } + + @Test + @TestMetadata("nestedLambdaInferenceWithListMap.kt") + public void testNestedLambdaInferenceWithListMap() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/nestedLambdaInferenceWithListMap.kt"); + } + + @Test + @TestMetadata("nestedSuspendCallInsideLambda.kt") + public void testNestedSuspendCallInsideLambda() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/nestedSuspendCallInsideLambda.kt"); + } + + @Test + @TestMetadata("plusAssignInCoroutineContext.kt") + public void testPlusAssignInCoroutineContext() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/plusAssignInCoroutineContext.kt"); + } + + @Test + @TestMetadata("plusAssignWithLambda.kt") + public void testPlusAssignWithLambda() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/plusAssignWithLambda.kt"); + } + + @Test + @TestMetadata("plusAssignWithLambda2.kt") + public void testPlusAssignWithLambda2() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/plusAssignWithLambda2.kt"); + } + + @Test + @TestMetadata("qualifiedResolvedExpressionInsideBuilderInference.kt") + public void testQualifiedResolvedExpressionInsideBuilderInference() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/qualifiedResolvedExpressionInsideBuilderInference.kt"); + } + + @Test + @TestMetadata("recursiveGenerators.kt") + public void testRecursiveGenerators() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/recursiveGenerators.kt"); + } + + @Test + @TestMetadata("recursiveGenerators2.kt") + public void testRecursiveGenerators2() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/recursiveGenerators2.kt"); + } + + @Test + @TestMetadata("returnTypeInference.kt") + public void testReturnTypeInference() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/returnTypeInference.kt"); + } + + @Test + @TestMetadata("returnTypeInference2.kt") + public void testReturnTypeInference2() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/returnTypeInference2.kt"); + } + + @Test + @TestMetadata("severalCandidatesWithDifferentVisibility.kt") + public void testSeveralCandidatesWithDifferentVisibility() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/severalCandidatesWithDifferentVisibility.kt"); + } + + @Test + @TestMetadata("simpleGenerator.kt") + public void testSimpleGenerator() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/simpleGenerator.kt"); + } + + @Test + @TestMetadata("suspendCallsWithErrors.kt") + public void testSuspendCallsWithErrors() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWithErrors.kt"); + } + + @Test + @TestMetadata("suspendCallsWrongUpperBound.kt") + public void testSuspendCallsWrongUpperBound() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWrongUpperBound.kt"); + } + + @Test + @TestMetadata("twoReceiversInScope.kt") + public void testTwoReceiversInScope() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/twoReceiversInScope.kt"); + } + + @Test + @TestMetadata("typeFromReceiver.kt") + public void testTypeFromReceiver() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/typeFromReceiver.kt"); + } + + @Test + @TestMetadata("variableCallInsideBuilderFunction.kt") + public void testVariableCallInsideBuilderFunction() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/variableCallInsideBuilderFunction.kt"); + } + + @Test + @TestMetadata("variableOfAFunctionTypeCall.kt") + public void testVariableOfAFunctionTypeCall() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/variableOfAFunctionTypeCall.kt"); + } + + @Test + @TestMetadata("withParameter.kt") + public void testWithParameter() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/withParameter.kt"); + } + + @Test + @TestMetadata("withUninferredParameter.kt") + public void testWithUninferredParameter() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/withUninferredParameter.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline") + @TestDataPath("$PROJECT_ROOT") + public class InlineCrossinline { + @Test + public void testAllFilesPresentInInlineCrossinline() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("inlineOrdinaryOfCrossinlineOrdinary.kt") + public void testInlineOrdinaryOfCrossinlineOrdinary() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineOrdinaryOfCrossinlineOrdinary.kt"); + } + + @Test + @TestMetadata("inlineOrdinaryOfCrossinlineSuspend.kt") + public void testInlineOrdinaryOfCrossinlineSuspend() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineOrdinaryOfCrossinlineSuspend.kt"); + } + + @Test + @TestMetadata("inlineOrdinaryOfNoinlineOrdinary.kt") + public void testInlineOrdinaryOfNoinlineOrdinary() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineOrdinaryOfNoinlineOrdinary.kt"); + } + + @Test + @TestMetadata("inlineOrdinaryOfNoinlineSuspend.kt") + public void testInlineOrdinaryOfNoinlineSuspend() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineOrdinaryOfNoinlineSuspend.kt"); + } + + @Test + @TestMetadata("inlineOrdinaryOfOrdinary.kt") + public void testInlineOrdinaryOfOrdinary() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineOrdinaryOfOrdinary.kt"); + } + + @Test + @TestMetadata("inlineOrdinaryOfSuspend.kt") + public void testInlineOrdinaryOfSuspend() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineOrdinaryOfSuspend.kt"); + } + + @Test + @TestMetadata("inlineSuspendOfCrossinlineOrdinary.kt") + public void testInlineSuspendOfCrossinlineOrdinary() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineSuspendOfCrossinlineOrdinary.kt"); + } + + @Test + @TestMetadata("inlineSuspendOfCrossinlineSuspend.kt") + public void testInlineSuspendOfCrossinlineSuspend() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineSuspendOfCrossinlineSuspend.kt"); + } + + @Test + @TestMetadata("inlineSuspendOfNoinlineOrdinary.kt") + public void testInlineSuspendOfNoinlineOrdinary() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineSuspendOfNoinlineOrdinary.kt"); + } + + @Test + @TestMetadata("inlineSuspendOfNoinlineSuspend.kt") + public void testInlineSuspendOfNoinlineSuspend() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineSuspendOfNoinlineSuspend.kt"); + } + + @Test + @TestMetadata("inlineSuspendOfOrdinary.kt") + public void testInlineSuspendOfOrdinary() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineSuspendOfOrdinary.kt"); + } + + @Test + @TestMetadata("inlineSuspendOfSuspend.kt") + public void testInlineSuspendOfSuspend() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineSuspendOfSuspend.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/release") + @TestDataPath("$PROJECT_ROOT") + public class Release { + @Test + public void testAllFilesPresentInRelease() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/release"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("suspend.kt") + public void testSuspend() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/release/suspend.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension") + @TestDataPath("$PROJECT_ROOT") + public class RestrictSuspension { + @Test + public void testAllFilesPresentInRestrictSuspension() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("allMembersAllowed.kt") + public void testAllMembersAllowed() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/allMembersAllowed.kt"); + } + + @Test + @TestMetadata("extensions.kt") + public void testExtensions() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/extensions.kt"); + } + + @Test + @TestMetadata("invokeExtension.kt") + public void testInvokeExtension() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/invokeExtension.kt"); + } + + @Test + @TestMetadata("memberExtension.kt") + public void testMemberExtension() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/memberExtension.kt"); + } + + @Test + @TestMetadata("notRelatedFun.kt") + public void testNotRelatedFun() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/notRelatedFun.kt"); + } + + @Test + @TestMetadata("outerYield_1_3.kt") + public void testOuterYield_1_3() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/outerYield_1_3.kt"); + } + + @Test + @TestMetadata("sameInstance.kt") + public void testSameInstance() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/sameInstance.kt"); + } + + @Test + @TestMetadata("simpleForbidden.kt") + public void testSimpleForbidden() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/simpleForbidden.kt"); + } + + @Test + @TestMetadata("wrongEnclosingFunction.kt") + public void testWrongEnclosingFunction() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/wrongEnclosingFunction.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType") + @TestDataPath("$PROJECT_ROOT") + public class SuspendFunctionType { + @Test + public void testAllFilesPresentInSuspendFunctionType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("functionVsSuspendFunction.kt") + public void testFunctionVsSuspendFunction() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/functionVsSuspendFunction.kt"); + } + + @Test + @TestMetadata("inference1.kt") + public void testInference1() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/inference1.kt"); + } + + @Test + @TestMetadata("inference2.kt") + public void testInference2() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/inference2.kt"); + } + + @Test + @TestMetadata("inference3.kt") + public void testInference3() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/inference3.kt"); + } + + @Test + @TestMetadata("inference4.kt") + public void testInference4() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/inference4.kt"); + } + + @Test + @TestMetadata("inline.kt") + public void testInline() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/inline.kt"); + } + + @Test + @TestMetadata("invoke.kt") + public void testInvoke() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/invoke.kt"); + } + + @Test + @TestMetadata("lambdaInOverriddenValInitializer.kt") + public void testLambdaInOverriddenValInitializer() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/lambdaInOverriddenValInitializer.kt"); + } + + @Test + @TestMetadata("lambdaInValInitializer.kt") + public void testLambdaInValInitializer() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/lambdaInValInitializer.kt"); + } + + @Test + @TestMetadata("modifierApplicability.kt") + public void testModifierApplicability() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/modifierApplicability.kt"); + } + + @Test + @TestMetadata("noInvokeForSuspendFunction.kt") + public void testNoInvokeForSuspendFunction() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/noInvokeForSuspendFunction.kt"); + } + + @Test + @TestMetadata("noValueParameters.kt") + public void testNoValueParameters() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/noValueParameters.kt"); + } + + @Test + @TestMetadata("nullableSuspendFunction.kt") + public void testNullableSuspendFunction() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/nullableSuspendFunction.kt"); + } + + @Test + @TestMetadata("suspendFunctionN.kt") + public void testSuspendFunctionN() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/suspendFunctionN.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls") + @TestDataPath("$PROJECT_ROOT") + public class TailCalls { + @Test + public void testAllFilesPresentInTailCalls() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("forbidden.kt") + public void testForbidden() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/forbidden.kt"); + } + + @Test + @TestMetadata("localFunctions.kt") + public void testLocalFunctions() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/localFunctions.kt"); + } + + @Test + @TestMetadata("nothingTypedSuspendFunction_1_3.kt") + public void testNothingTypedSuspendFunction_1_3() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/nothingTypedSuspendFunction_1_3.kt"); + } + + @Test + @TestMetadata("recursive.kt") + public void testRecursive() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/recursive.kt"); + } + + @Test + @TestMetadata("tryCatch.kt") + public void testTryCatch() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/tryCatch.kt"); + } + + @Test + @TestMetadata("valid.kt") + public void testValid() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/valid.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/deprecated") + @TestDataPath("$PROJECT_ROOT") + public class Deprecated { + @Test + public void testAllFilesPresentInDeprecated() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/deprecated"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("deprecationOnReadBytes.kt") + public void testDeprecationOnReadBytes() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/deprecated/deprecationOnReadBytes.kt"); + } + + @Test + @TestMetadata("noDeprecationOnReadBytes.kt") + public void testNoDeprecationOnReadBytes() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/deprecated/noDeprecationOnReadBytes.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature") + @TestDataPath("$PROJECT_ROOT") + public class DuplicateJvmSignature { + @Test + public void testAllFilesPresentInDuplicateJvmSignature() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("delegatedProperty.kt") + public void testDelegatedProperty() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/delegatedProperty.kt"); + } + + @Test + @TestMetadata("jvmNames.kt") + public void testJvmNames() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/jvmNames.kt"); + } + + @Test + @TestMetadata("jvmNamesDuplicate.kt") + public void testJvmNamesDuplicate() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/jvmNamesDuplicate.kt"); + } + + @Test + @TestMetadata("jvmOverloads.kt") + public void testJvmOverloads() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/jvmOverloads.kt"); + } + + @Test + @TestMetadata("jvmStaticInClassObject.kt") + public void testJvmStaticInClassObject() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/jvmStaticInClassObject.kt"); + } + + @Test + @TestMetadata("jvmStaticInObject.kt") + public void testJvmStaticInObject() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/jvmStaticInObject.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics") + @TestDataPath("$PROJECT_ROOT") + public class Statics { + @Test + public void testAllFilesPresentInStatics() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("jjk.kt") + public void testJjk() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jjk.kt"); + } + + @Test + @TestMetadata("jk.kt") + public void testJk() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jk.kt"); + } + + @Test + @TestMetadata("jkjk.kt") + public void testJkjk() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jkjk.kt"); + } + + @Test + @TestMetadata("kotlinMembersVsJavaNonVisibleStatics.kt") + public void testKotlinMembersVsJavaNonVisibleStatics() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/evaluate") + @TestDataPath("$PROJECT_ROOT") + public class Evaluate { + @Test + public void testAllFilesPresentInEvaluate() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/evaluate"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("charCodeExpType.kt") + public void testCharCodeExpType() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/evaluate/charCodeExpType.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/experimental") + @TestDataPath("$PROJECT_ROOT") + public class Experimental { + @Test + public void testAllFilesPresentInExperimental() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/experimental"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("annotation.kt") + public void testAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/annotation.kt"); + } + + @Test + @TestMetadata("bodyUsages.kt") + public void testBodyUsages() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/bodyUsages.kt"); + } + + @Test + @TestMetadata("bodyUsagesAndInline.kt") + public void testBodyUsagesAndInline() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/bodyUsagesAndInline.kt"); + } + + @Test + @TestMetadata("callOfBaseFunctionFromGeneric.kt") + public void testCallOfBaseFunctionFromGeneric() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/callOfBaseFunctionFromGeneric.kt"); + } + + @Test + @TestMetadata("classMembers.kt") + public void testClassMembers() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/classMembers.kt"); + } + + @Test + @TestMetadata("classMembersOverlyExperimental.kt") + public void testClassMembersOverlyExperimental() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/classMembersOverlyExperimental.kt"); + } + + @Test + @TestMetadata("constVal.kt") + public void testConstVal() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/constVal.kt"); + } + + @Test + @TestMetadata("constructorCheck.kt") + public void testConstructorCheck() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/constructorCheck.kt"); + } + + @Test + @TestMetadata("deeplyNestedClass.kt") + public void testDeeplyNestedClass() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/deeplyNestedClass.kt"); + } + + @Test + @TestMetadata("duration.kt") + public void testDuration() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/duration.kt"); + } + + @Test + @TestMetadata("errors.kt") + public void testErrors() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/errors.kt"); + } + + @Test + @TestMetadata("experimentalAfterRelease.kt") + public void testExperimentalAfterRelease() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalAfterRelease.kt"); + } + + @Test + @TestMetadata("experimentalAnnotationOnConstructorProperty.kt") + public void testExperimentalAnnotationOnConstructorProperty() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalAnnotationOnConstructorProperty.kt"); + } + + @Test + @TestMetadata("experimentalIsNotEnabled.kt") + public void testExperimentalIsNotEnabled() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalIsNotEnabled.kt"); + } + + @Test + @TestMetadata("experimentalSetter.kt") + public void testExperimentalSetter() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalSetter.kt"); + } + + @Test + @TestMetadata("fileOptInSuppressesOverride.kt") + public void testFileOptInSuppressesOverride() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/fileOptInSuppressesOverride.kt"); + } + + @Test + @TestMetadata("fullFqNameUsage.kt") + public void testFullFqNameUsage() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/fullFqNameUsage.kt"); + } + + @Test + @TestMetadata("implicitUsages.kt") + public void testImplicitUsages() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/implicitUsages.kt"); + } + + @Test + @TestMetadata("implicitUsagesFuture.kt") + public void testImplicitUsagesFuture() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/implicitUsagesFuture.kt"); + } + + @Test + @TestMetadata("importStatement.kt") + public void testImportStatement() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/importStatement.kt"); + } + + @Test + @TestMetadata("incorrectTargetsForExperimentalAnnotation.kt") + public void testIncorrectTargetsForExperimentalAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/incorrectTargetsForExperimentalAnnotation.kt"); + } + + @Test + @TestMetadata("incorrectUseExperimental.kt") + public void testIncorrectUseExperimental() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/incorrectUseExperimental.kt"); + } + + @Test + @TestMetadata("insideSAM.kt") + public void testInsideSAM() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/insideSAM.kt"); + } + + @Test + @TestMetadata("noRetentionAfter.kt") + public void testNoRetentionAfter() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/noRetentionAfter.kt"); + } + + @Test + @TestMetadata("overridableCheck.kt") + public void testOverridableCheck() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/overridableCheck.kt"); + } + + @Test + @TestMetadata("override.kt") + public void testOverride() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/override.kt"); + } + + @Test + @TestMetadata("overrideDifferentExperimentalities.kt") + public void testOverrideDifferentExperimentalities() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/overrideDifferentExperimentalities.kt"); + } + + @Test + @TestMetadata("overrideInAnonymousObject.kt") + public void testOverrideInAnonymousObject() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/overrideInAnonymousObject.kt"); + } + + @Test + @TestMetadata("overrideInPrimaryConstructor.kt") + public void testOverrideInPrimaryConstructor() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/overrideInPrimaryConstructor.kt"); + } + + @Test + @TestMetadata("subClassOptInModality.kt") + public void testSubClassOptInModality() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/subClassOptInModality.kt"); + } + + @Test + @TestMetadata("subClassOptInRequired.kt") + public void testSubClassOptInRequired() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/subClassOptInRequired.kt"); + } + + @Test + @TestMetadata("subclassOptInInheritance.kt") + public void testSubclassOptInInheritance() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/subclassOptInInheritance.kt"); + } + + @Test + @TestMetadata("topLevel.kt") + public void testTopLevel() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/topLevel.kt"); + } + + @Test + @TestMetadata("typealias.kt") + public void testTypealias() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/typealias.kt"); + } + + @Test + @TestMetadata("usageNotAsAnnotation.kt") + public void testUsageNotAsAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/usageNotAsAnnotation.kt"); + } + + @Test + @TestMetadata("useExperimentalOnFile.kt") + public void testUseExperimentalOnFile() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnFile.kt"); + } + + @Test + @TestMetadata("useExperimentalOnFileWithVeryExperimentalMarker.kt") + public void testUseExperimentalOnFileWithVeryExperimentalMarker() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnFileWithVeryExperimentalMarker.kt"); + } + + @Test + @TestMetadata("useExperimentalOnStatement.kt") + public void testUseExperimentalOnStatement() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnStatement.kt"); + } + + @Test + @TestMetadata("useExperimentalOnWholeModule.kt") + public void testUseExperimentalOnWholeModule() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnWholeModule.kt"); + } + + @Test + @TestMetadata("useExperimentalTargets.kt") + public void testUseExperimentalTargets() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalTargets.kt"); + } + + @Test + @TestMetadata("useExperimentalWithSeveralAnnotations.kt") + public void testUseExperimentalWithSeveralAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalWithSeveralAnnotations.kt"); + } + + @Test + @TestMetadata("wasExperimental.kt") + public void testWasExperimental() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/wasExperimental.kt"); + } + + @Test + @TestMetadata("wrongTargetsWithoutExplicitTarget.kt") + public void testWrongTargetsWithoutExplicitTarget() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/wrongTargetsWithoutExplicitTarget.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/factoryPattern") + @TestDataPath("$PROJECT_ROOT") + public class FactoryPattern { + @Test + public void testAllFilesPresentInFactoryPattern() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/factoryPattern"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("independentResolutionInLambda.kt") + public void testIndependentResolutionInLambda() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/factoryPattern/independentResolutionInLambda.kt"); + } + + @Test + @TestMetadata("multipleOverloads_1.kt") + public void testMultipleOverloads_1() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/factoryPattern/multipleOverloads_1.kt"); + } + + @Test + @TestMetadata("multipleOverloads_2.kt") + public void testMultipleOverloads_2() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/factoryPattern/multipleOverloads_2.kt"); + } + + @Test + @TestMetadata("multipleOverloads_3.kt") + public void testMultipleOverloads_3() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/factoryPattern/multipleOverloads_3.kt"); + } + + @Test + @TestMetadata("overloadByLambdaReturnType_disabled.kt") + public void testOverloadByLambdaReturnType_disabled() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/factoryPattern/overloadByLambdaReturnType_disabled.kt"); + } + + @Test + @TestMetadata("overloadByLambdaReturnType_enabled.kt") + public void testOverloadByLambdaReturnType_enabled() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/factoryPattern/overloadByLambdaReturnType_enabled.kt"); + } + + @Test + @TestMetadata("overloadByLambdaReturnType_enabled_no_annotation.kt") + public void testOverloadByLambdaReturnType_enabled_no_annotation() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/factoryPattern/overloadByLambdaReturnType_enabled_no_annotation.kt"); + } + + @Test + @TestMetadata("referenceWithTheSameNameAsContainingProperty.kt") + public void testReferenceWithTheSameNameAsContainingProperty() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/factoryPattern/referenceWithTheSameNameAsContainingProperty.kt"); + } + + @Test + @TestMetadata("resolutionInOldInference.kt") + public void testResolutionInOldInference() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/factoryPattern/resolutionInOldInference.kt"); + } + + @Test + @TestMetadata("returnFromInlineLambda.kt") + public void testReturnFromInlineLambda() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/factoryPattern/returnFromInlineLambda.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/forInArrayLoop") + @TestDataPath("$PROJECT_ROOT") + public class ForInArrayLoop { + @Test + public void testAllFilesPresentInForInArrayLoop() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/forInArrayLoop"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("capturedRangeVariableAssignmentBefore13.kt") + public void testCapturedRangeVariableAssignmentBefore13() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/forInArrayLoop/capturedRangeVariableAssignmentBefore13.kt"); + } + + @Test + @TestMetadata("forInFieldUpdatedInLoopBodyBefore13.kt") + public void testForInFieldUpdatedInLoopBodyBefore13() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/forInArrayLoop/forInFieldUpdatedInLoopBodyBefore13.kt"); + } + + @Test + @TestMetadata("rangeLocalDelegatedPropertyAssignmentBefore13.kt") + public void testRangeLocalDelegatedPropertyAssignmentBefore13() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/forInArrayLoop/rangeLocalDelegatedPropertyAssignmentBefore13.kt"); + } + + @Test + @TestMetadata("rangeVariableAssignment13.kt") + public void testRangeVariableAssignment13() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/forInArrayLoop/rangeVariableAssignment13.kt"); + } + + @Test + @TestMetadata("rangeVariableAssignmentBefore13.kt") + public void testRangeVariableAssignmentBefore13() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/forInArrayLoop/rangeVariableAssignmentBefore13.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/functionLiterals") + @TestDataPath("$PROJECT_ROOT") + public class FunctionLiterals { + @Test + public void testAllFilesPresentInFunctionLiterals() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/functionLiterals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("nullableUnitLiteral.kt") + public void testNullableUnitLiteral() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/functionLiterals/nullableUnitLiteral.kt"); + } + + @Test + @TestMetadata("pseudocodeMemoryOverhead.kt") + public void testPseudocodeMemoryOverhead() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/functionLiterals/pseudocodeMemoryOverhead.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/inference") + @TestDataPath("$PROJECT_ROOT") + public class Inference { + @Test + public void testAllFilesPresentInInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("arrayConstructor.kt") + public void testArrayConstructor() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/arrayConstructor.kt"); + } + + @Test + @TestMetadata("callableReferenceOnParameter.kt") + public void testCallableReferenceOnParameter() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/callableReferenceOnParameter.kt"); + } + + @Test + @TestMetadata("integerLiterals.kt") + public void testIntegerLiterals() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/integerLiterals.kt"); + } + + @Test + @TestMetadata("intersectDfiTypesBeforeCapturing.kt") + public void testIntersectDfiTypesBeforeCapturing() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/intersectDfiTypesBeforeCapturing.kt"); + } + + @Test + @TestMetadata("intersectionInputType.kt") + public void testIntersectionInputType() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/intersectionInputType.kt"); + } + + @Test + @TestMetadata("kt11266.kt") + public void testKt11266() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt11266.kt"); + } + + @Test + @TestMetadata("kt12008.kt") + public void testKt12008() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt12008.kt"); + } + + @Test + @TestMetadata("kt1558.kt") + public void testKt1558() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt1558.kt"); + } + + @Test + @TestMetadata("kt27772.kt") + public void testKt27772() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt27772.kt"); + } + + @Test + @TestMetadata("kt30292.kt") + public void testKt30292() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt30292.kt"); + } + + @Test + @TestMetadata("kt32345.kt") + public void testKt32345() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt32345.kt"); + } + + @Test + @TestMetadata("kt3458.kt") + public void testKt3458() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt3458.kt"); + } + + @Test + @TestMetadata("kt35847.kt") + public void testKt35847() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt35847.kt"); + } + + @Test + @TestMetadata("kt36249.kt") + public void testKt36249() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt36249.kt"); + } + + @Test + @TestMetadata("kt36951.kt") + public void testKt36951() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt36951.kt"); + } + + @Test + @TestMetadata("kt37627.kt") + public void testKt37627() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt37627.kt"); + } + + @Test + @TestMetadata("kt38143.kt") + public void testKt38143() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt38143.kt"); + } + + @Test + @TestMetadata("kt38737.kt") + public void testKt38737() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt38737.kt"); + } + + @Test + @TestMetadata("kt38801.kt") + public void testKt38801() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt38801.kt"); + } + + @Test + @TestMetadata("kt42620.kt") + public void testKt42620() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt42620.kt"); + } + + @Test + @TestMetadata("kt4975.kt") + public void testKt4975() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt4975.kt"); + } + + @Test + @TestMetadata("plusAssignOnArrayList.kt") + public void testPlusAssignOnArrayList() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/plusAssignOnArrayList.kt"); + } + + @Test + @TestMetadata("recursiveFlexibleAssertions.kt") + public void testRecursiveFlexibleAssertions() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/recursiveFlexibleAssertions.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve") + @TestDataPath("$PROJECT_ROOT") + public class AnnotationsForResolve { + @Test + public void testAllFilesPresentInAnnotationsForResolve() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("checkLowPriorityIsResolvedSuccessfully.kt") + public void testCheckLowPriorityIsResolvedSuccessfully() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/checkLowPriorityIsResolvedSuccessfully.kt"); + } + + @Test + @TestMetadata("exactAnnotation.kt") + public void testExactAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/exactAnnotation.kt"); + } + + @Test + @TestMetadata("exactAnnotationWithUpperBoundConstraint.kt") + public void testExactAnnotationWithUpperBoundConstraint() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/exactAnnotationWithUpperBoundConstraint.kt"); + } + + @Test + @TestMetadata("explicitTypeArgumentAsValidInputType.kt") + public void testExplicitTypeArgumentAsValidInputType() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/explicitTypeArgumentAsValidInputType.kt"); + } + + @Test + @TestMetadata("internalAnnotationsOnTypes.kt") + public void testInternalAnnotationsOnTypes() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/internalAnnotationsOnTypes.kt"); + } + + @Test + @TestMetadata("kt26698.kt") + public void testKt26698() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt26698.kt"); + } + + @Test + @TestMetadata("kt29307.kt") + public void testKt29307() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt29307.kt"); + } + + @Test + @TestMetadata("kt35210.kt") + public void testKt35210() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt35210.kt"); + } + + @Test + @TestMetadata("moreOnlyInputTypes.kt") + public void testMoreOnlyInputTypes() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/moreOnlyInputTypes.kt"); + } + + @Test + @TestMetadata("noInferAndLowPriority.kt") + public void testNoInferAndLowPriority() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAndLowPriority.kt"); + } + + @Test + @TestMetadata("noInferAnnotation.kt") + public void testNoInferAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAnnotation.kt"); + } + + @Test + @TestMetadata("notNullAnnotation.kt") + public void testNotNullAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/notNullAnnotation.kt"); + } + + @Test + @TestMetadata("onlyInputTypeAndJava.kt") + public void testOnlyInputTypeAndJava() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypeAndJava.kt"); + } + + @Test + @TestMetadata("onlyInputTypeRecursiveBoundAndProjections.kt") + public void testOnlyInputTypeRecursiveBoundAndProjections() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypeRecursiveBoundAndProjections.kt"); + } + + @Test + @TestMetadata("onlyInputTypes.kt") + public void testOnlyInputTypes() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypes.kt"); + } + + @Test + @TestMetadata("onlyInputTypesAndClassLiterals.kt") + public void testOnlyInputTypesAndClassLiterals() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndClassLiterals.kt"); + } + + @Test + @TestMetadata("onlyInputTypesAndLowPriority.kt") + public void testOnlyInputTypesAndLowPriority() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndLowPriority.kt"); + } + + @Test + @TestMetadata("onlyInputTypesAndTopLevelCapturedTypes.kt") + public void testOnlyInputTypesAndTopLevelCapturedTypes() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndTopLevelCapturedTypes.kt"); + } + + @Test + @TestMetadata("onlyInputTypesAnnotationWithPlatformTypes.kt") + public void testOnlyInputTypesAnnotationWithPlatformTypes() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAnnotationWithPlatformTypes.kt"); + } + + @Test + @TestMetadata("onlyInputTypesCaptured.kt") + public void testOnlyInputTypesCaptured() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesCaptured.kt"); + } + + @Test + @TestMetadata("onlyInputTypesCommonConstraintSystem.kt") + public void testOnlyInputTypesCommonConstraintSystem() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesCommonConstraintSystem.kt"); + } + + @Test + @TestMetadata("onlyInputTypesUpperBound.kt") + public void testOnlyInputTypesUpperBound() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesUpperBound.kt"); + } + + @Test + @TestMetadata("onlyInputTypesWarning.kt") + public void testOnlyInputTypesWarning() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesWarning.kt"); + } + + @Test + @TestMetadata("onlyInputTypesWithVarargs.kt") + public void testOnlyInputTypesWithVarargs() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesWithVarargs.kt"); + } + + @Test + @TestMetadata("propagationOfNoInferAnnotation.kt") + public void testPropagationOfNoInferAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/propagationOfNoInferAnnotation.kt"); + } + + @Test + @TestMetadata("resolveWithOnlyInputTypesAnnotation.kt") + public void testResolveWithOnlyInputTypesAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/resolveWithOnlyInputTypesAnnotation.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/completion") + @TestDataPath("$PROJECT_ROOT") + public class Completion { + @Test + public void testAllFilesPresentInCompletion() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/completion"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis") + @TestDataPath("$PROJECT_ROOT") + public class PostponedArgumentsAnalysis { + @Test + public void testAllFilesPresentInPostponedArgumentsAnalysis() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("callableReferences.kt") + public void testCallableReferences() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/callableReferences.kt"); + } + + @Test + @TestMetadata("complexInterdependentInputOutputTypes.kt") + public void testComplexInterdependentInputOutputTypes() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/complexInterdependentInputOutputTypes.kt"); + } + + @Test + @TestMetadata("deepLambdas.kt") + public void testDeepLambdas() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/deepLambdas.kt"); + } + + @Test + @TestMetadata("fixIndependentVariables.kt") + public void testFixIndependentVariables() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/fixIndependentVariables.kt"); + } + + @Test + @TestMetadata("fixInputTypeToMoreSpecificType.kt") + public void testFixInputTypeToMoreSpecificType() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/fixInputTypeToMoreSpecificType.kt"); + } + + @Test + @TestMetadata("fixReceiverToMoreSpecificType.kt") + public void testFixReceiverToMoreSpecificType() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/fixReceiverToMoreSpecificType.kt"); + } + + @Test + @TestMetadata("kt38799.kt") + public void testKt38799() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/kt38799.kt"); + } + + @Test + @TestMetadata("manyArguments.kt") + public void testManyArguments() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/manyArguments.kt"); + } + + @Test + @TestMetadata("moreSpecificOutputType.kt") + public void testMoreSpecificOutputType() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/moreSpecificOutputType.kt"); + } + + @Test + @TestMetadata("rerunStagesAfterFixationInFullMode.kt") + public void testRerunStagesAfterFixationInFullMode() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/rerunStagesAfterFixationInFullMode.kt"); + } + + @Test + @TestMetadata("rerunStagesAfterFixationInPartialMode.kt") + public void testRerunStagesAfterFixationInPartialMode() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/rerunStagesAfterFixationInPartialMode.kt"); + } + + @Test + @TestMetadata("suspendFunctions.kt") + public void testSuspendFunctions() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/suspendFunctions.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/performance") + @TestDataPath("$PROJECT_ROOT") + public class Performance { + @Test + public void testAllFilesPresentInPerformance() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/performance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("reuseBuiltFunctionalTypesForIdLambdas.kt") + public void testReuseBuiltFunctionalTypesForIdLambdas() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/performance/reuseBuiltFunctionalTypesForIdLambdas.kt"); + } + + @Test + @TestMetadata("reuseBuiltFunctionalTypesForLambdas.kt") + public void testReuseBuiltFunctionalTypesForLambdas() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/performance/reuseBuiltFunctionalTypesForLambdas.kt"); + } + + @Test + @TestMetadata("reuseBuiltFunctionalTypesForPairOfLambdas.kt") + public void testReuseBuiltFunctionalTypesForPairOfLambdas() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/performance/reuseBuiltFunctionalTypesForPairOfLambdas.kt"); + } + + @Test + @TestMetadata("reuseBuiltFunctionalTypesForPairsOfDeepLambdas.kt") + public void testReuseBuiltFunctionalTypesForPairsOfDeepLambdas() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/performance/reuseBuiltFunctionalTypesForPairsOfDeepLambdas.kt"); + } + + @Test + @TestMetadata("reuseBuiltFunctionalTypesForPairsOfDeepMixedLambdas.kt") + public void testReuseBuiltFunctionalTypesForPairsOfDeepMixedLambdas() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/performance/reuseBuiltFunctionalTypesForPairsOfDeepMixedLambdas.kt"); + } + + @Test + @TestMetadata("reuseBuiltFunctionalTypesForPairsOfIdLambdas.kt") + public void testReuseBuiltFunctionalTypesForPairsOfIdLambdas() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/performance/reuseBuiltFunctionalTypesForPairsOfIdLambdas.kt"); + } + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/delegates") + @TestDataPath("$PROJECT_ROOT") + public class Delegates { + @Test + public void testAllFilesPresentInDelegates() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/delegates"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("kt31219.kt") + public void testKt31219() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/delegates/kt31219.kt"); + } + + @Test + @TestMetadata("kt31679.kt") + public void testKt31679() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/delegates/kt31679.kt"); + } + + @Test + @TestMetadata("kt32249.kt") + public void testKt32249() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/delegates/kt32249.kt"); + } + + @Test + @TestMetadata("kt50994.kt") + public void testKt50994() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/delegates/kt50994.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/nothingType") + @TestDataPath("$PROJECT_ROOT") + public class NothingType { + @Test + public void testAllFilesPresentInNothingType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/nothingType"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("dontInferToNullableNothingInDelegates.kt") + public void testDontInferToNullableNothingInDelegates() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/nothingType/dontInferToNullableNothingInDelegates.kt"); + } + + @Test + @TestMetadata("dontSpreadWarningToNotReturningNothingSubResolvedAtoms.kt") + public void testDontSpreadWarningToNotReturningNothingSubResolvedAtoms() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/nothingType/dontSpreadWarningToNotReturningNothingSubResolvedAtoms.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/performance") + @TestDataPath("$PROJECT_ROOT") + public class Performance { + @Test + public void testAllFilesPresentInPerformance() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/performance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("kt41644.kt") + public void testKt41644() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/performance/kt41644.kt"); + } + + @Test + @TestMetadata("kt41741.kt") + public void testKt41741() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/performance/kt41741.kt"); + } + + @Test + @TestMetadata("kt42195.kt") + public void testKt42195() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inference/performance/kt42195.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/inline") + @TestDataPath("$PROJECT_ROOT") + public class Inline { + @Test + public void testAllFilesPresentInInline() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inline"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("inlineConstructorOfArray.kt") + public void testInlineConstructorOfArray() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inline/inlineConstructorOfArray.kt"); + } + + @Test + @TestMetadata("inlineOnlySuppressesNothingToInline.kt") + public void testInlineOnlySuppressesNothingToInline() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inline/inlineOnlySuppressesNothingToInline.kt"); + } + + @Test + @TestMetadata("synchronizedOnInline.kt") + public void testSynchronizedOnInline() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/inline/synchronizedOnInline.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/java") + @TestDataPath("$PROJECT_ROOT") + public class Java { + @Test + public void testAllFilesPresentInJava() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/java"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("assertThatOnMap.kt") + public void testAssertThatOnMap() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/java/assertThatOnMap.kt"); + } + + @Test + @TestMetadata("checkEnhancedUpperBounds.kt") + public void testCheckEnhancedUpperBounds() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/java/checkEnhancedUpperBounds.kt"); + } + + @Test + @TestMetadata("checkEnhancedUpperBoundsWithEnabledImprovements.kt") + public void testCheckEnhancedUpperBoundsWithEnabledImprovements() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/java/checkEnhancedUpperBoundsWithEnabledImprovements.kt"); + } + + @Test + @TestMetadata("concurrentHashMapContains.kt") + public void testConcurrentHashMapContains() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContains.kt"); + } + + @Test + @TestMetadata("concurrentHashMapContainsError.kt") + public void testConcurrentHashMapContainsError() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContainsError.kt"); + } + + @Test + @TestMetadata("functionN.kt") + public void testFunctionN() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/java/functionN.kt"); + } + + @Test + @TestMetadata("inheritedFunctionN.kt") + public void testInheritedFunctionN() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/java/inheritedFunctionN.kt"); + } + + @Test + @TestMetadata("intersectFlexibleAndMutable.kt") + public void testIntersectFlexibleAndMutable() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/java/intersectFlexibleAndMutable.kt"); + } + + @Test + @TestMetadata("patternCompileCallableReference.kt") + public void testPatternCompileCallableReference() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/java/patternCompileCallableReference.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/kt7585") + @TestDataPath("$PROJECT_ROOT") + public class Kt7585 { + @Test + public void testAllFilesPresentInKt7585() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/kt7585"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("delegate.kt") + public void testDelegate() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/kt7585/delegate.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/lateinit") + @TestDataPath("$PROJECT_ROOT") + public class Lateinit { + @Test + public void testAllFilesPresentInLateinit() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/lateinit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("isInitialized.kt") + public void testIsInitialized() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/lateinit/isInitialized.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/multiplatform") + @TestDataPath("$PROJECT_ROOT") + public class Multiplatform { + @Test + public void testAllFilesPresentInMultiplatform() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/multiplatform"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("jvmOverloads.kt") + public void testJvmOverloads() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/multiplatform/jvmOverloads.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection") + @TestDataPath("$PROJECT_ROOT") + public class PurelyImplementedCollection { + @Test + public void testAllFilesPresentInPurelyImplementedCollection() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("arrayList.kt") + public void testArrayList() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/arrayList.kt"); + } + + @Test + @TestMetadata("arrayListNullable.kt") + public void testArrayListNullable() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/arrayListNullable.kt"); + } + + @Test + @TestMetadata("customClassMutableCollection.kt") + public void testCustomClassMutableCollection() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableCollection.kt"); + } + + @Test + @TestMetadata("customClassMutableList.kt") + public void testCustomClassMutableList() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableList.kt"); + } + + @Test + @TestMetadata("invalidFqName.kt") + public void testInvalidFqName() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/invalidFqName.kt"); + } + + @Test + @TestMetadata("maps.kt") + public void testMaps() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/maps.kt"); + } + + @Test + @TestMetadata("mapsWithNullableKey.kt") + public void testMapsWithNullableKey() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableKey.kt"); + } + + @Test + @TestMetadata("mapsWithNullableValues.kt") + public void testMapsWithNullableValues() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableValues.kt"); + } + + @Test + @TestMetadata("sets.kt") + public void testSets() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/sets.kt"); + } + + @Test + @TestMetadata("wrongTypeParametersCount.kt") + public void testWrongTypeParametersCount() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/wrongTypeParametersCount.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/reflection") + @TestDataPath("$PROJECT_ROOT") + public class Reflection { + @Test + public void testAllFilesPresentInReflection() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/reflection"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("classArrayInAnnotation.kt") + public void testClassArrayInAnnotation() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/reflection/classArrayInAnnotation.kt"); + } + + @Test + @TestMetadata("noReflectionInClassPath.kt") + public void testNoReflectionInClassPath() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/reflection/noReflectionInClassPath.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/regression") + @TestDataPath("$PROJECT_ROOT") + public class Regression { + @Test + public void testAllFilesPresentInRegression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/regression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("ea63992.kt") + public void testEa63992() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/regression/ea63992.kt"); + } + + @Test + @TestMetadata("ea65206.kt") + public void testEa65206() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/regression/ea65206.kt"); + } + + @Test + @TestMetadata("ea66827_dataClassWrongToString.kt") + public void testEa66827_dataClassWrongToString() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/regression/ea66827_dataClassWrongToString.kt"); + } + + @Test + @TestMetadata("ea70485_functionTypeInheritor.kt") + public void testEa70485_functionTypeInheritor() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/regression/ea70485_functionTypeInheritor.kt"); + } + + @Test + @TestMetadata("ea70880_illegalJvmName.kt") + public void testEa70880_illegalJvmName() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/regression/ea70880_illegalJvmName.kt"); + } + + @Test + @TestMetadata("kt10001.kt") + public void testKt10001() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/regression/kt10001.kt"); + } + + @Test + @TestMetadata("kt2082.kt") + public void testKt2082() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/regression/kt2082.kt"); + } + + @Test + @TestMetadata("kt26806.kt") + public void testKt26806() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/regression/kt26806.kt"); + } + + @Test + @TestMetadata("kt34391.kt") + public void testKt34391() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/regression/kt34391.kt"); + } + + @Test + @TestMetadata("kt37554.kt") + public void testKt37554() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/regression/kt37554.kt"); + } + + @Test + @TestMetadata("kt37706.kt") + public void testKt37706() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/regression/kt37706.kt"); + } + + @Test + @TestMetadata("kt37727.kt") + public void testKt37727() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/regression/kt37727.kt"); + } + + @Test + @TestMetadata("kt37735.kt") + public void testKt37735() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/regression/kt37735.kt"); + } + + @Test + @TestMetadata("kt9820_javaFunctionTypeInheritor.kt") + public void testKt9820_javaFunctionTypeInheritor() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/regression/kt9820_javaFunctionTypeInheritor.kt"); + } + + @Test + @TestMetadata("kt-37497.kt") + public void testKt_37497() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/regression/kt-37497.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/reified") + @TestDataPath("$PROJECT_ROOT") + public class Reified { + @Test + public void testAllFilesPresentInReified() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/reified"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("arrayConstruction.kt") + public void testArrayConstruction() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/reified/arrayConstruction.kt"); + } + + @Test + @TestMetadata("arrayOfNullsReified.kt") + public void testArrayOfNullsReified() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/reified/arrayOfNullsReified.kt"); + } + + @Test + @TestMetadata("kt11881.kt") + public void testKt11881() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/reified/kt11881.kt"); + } + + @Test + @TestMetadata("nonCallableReiefied.kt") + public void testNonCallableReiefied() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/reified/nonCallableReiefied.kt"); + } + + @Test + @TestMetadata("reifiedNothingSubstitution.kt") + public void testReifiedNothingSubstitution() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/reified/reifiedNothingSubstitution.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/resolve") + @TestDataPath("$PROJECT_ROOT") + public class Resolve { + @Test + public void testAllFilesPresentInResolve() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/resolve"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("forEachInLocalClass.kt") + public void testForEachInLocalClass() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/forEachInLocalClass.kt"); + } + + @Test + @TestMetadata("hidesMembers.kt") + public void testHidesMembers() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/hidesMembers.kt"); + } + + @Test + @TestMetadata("hidesMembers2.kt") + public void testHidesMembers2() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/hidesMembers2.kt"); + } + + @Test + @TestMetadata("javaPackageMembers.kt") + public void testJavaPackageMembers() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/javaPackageMembers.kt"); + } + + @Test + @TestMetadata("javaStaticMembers.kt") + public void testJavaStaticMembers() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/javaStaticMembers.kt"); + } + + @Test + @TestMetadata("kt10103.kt") + public void testKt10103() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/kt10103.kt"); + } + + @Test + @TestMetadata("kt10732a.kt") + public void testKt10732a() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/kt10732a.kt"); + } + + @Test + @TestMetadata("kt4711.kt") + public void testKt4711() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/kt4711.kt"); + } + + @Test + @TestMetadata("lambdaArgumentOfInapplicableCall.kt") + public void testLambdaArgumentOfInapplicableCall() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/lambdaArgumentOfInapplicableCall.kt"); + } + + @Test + @TestMetadata("samAgainstFunctionalType.kt") + public void testSamAgainstFunctionalType() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/samAgainstFunctionalType.kt"); + } + + @Test + @TestMetadata("samConstructorVsFun.kt") + public void testSamConstructorVsFun() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/samConstructorVsFun.kt"); + } + + @Test + @TestMetadata("samOverloadsWithGenerics.kt") + public void testSamOverloadsWithGenerics() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithGenerics.kt"); + } + + @Test + @TestMetadata("samOverloadsWithKtFunction.kt") + public void testSamOverloadsWithKtFunction() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithKtFunction.kt"); + } + + @Test + @TestMetadata("sameNameClassesFromSupertypes.kt") + public void testSameNameClassesFromSupertypes() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/sameNameClassesFromSupertypes.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/smartcasts") + @TestDataPath("$PROJECT_ROOT") + public class Smartcasts { + @Test + public void testAllFilesPresentInSmartcasts() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/smartcasts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("forEachSafe.kt") + public void testForEachSafe() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/forEachSafe.kt"); + } + + @Test + @TestMetadata("forEachUnsafe.kt") + public void testForEachUnsafe() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/forEachUnsafe.kt"); + } + + @Test + @TestMetadata("kt10463.kt") + public void testKt10463() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/kt10463.kt"); + } + + @Test + @TestMetadata("lambdaInCallArgs.kt") + public void testLambdaInCallArgs() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/lambdaInCallArgs.kt"); + } + + @Test + @TestMetadata("lazyDeclaresAndModifies.kt") + public void testLazyDeclaresAndModifies() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/lazyDeclaresAndModifies.kt"); + } + + @Test + @TestMetadata("letAlwaysChangesToNotNull.kt") + public void testLetAlwaysChangesToNotNull() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/letAlwaysChangesToNotNull.kt"); + } + + @Test + @TestMetadata("letChangesToNotNull.kt") + public void testLetChangesToNotNull() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/letChangesToNotNull.kt"); + } + + @Test + @TestMetadata("letChangesToNull.kt") + public void testLetChangesToNull() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/letChangesToNull.kt"); + } + + @Test + @TestMetadata("letChangesToNullComplex.kt") + public void testLetChangesToNullComplex() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/letChangesToNullComplex.kt"); + } + + @Test + @TestMetadata("letMergeNotNull.kt") + public void testLetMergeNotNull() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/letMergeNotNull.kt"); + } + + @Test + @TestMetadata("letStable.kt") + public void testLetStable() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/letStable.kt"); + } + + @Test + @TestMetadata("letUsesOwnReceiver.kt") + public void testLetUsesOwnReceiver() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/letUsesOwnReceiver.kt"); + } + + @Test + @TestMetadata("listOfGeneric.kt") + public void testListOfGeneric() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/listOfGeneric.kt"); + } + + @Test + @TestMetadata("unsoundSmartcast.kt") + public void testUnsoundSmartcast() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/unsoundSmartcast.kt"); + } + + @Test + @TestMetadata("withChangesToNull.kt") + public void testWithChangesToNull() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/withChangesToNull.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/targetedBuiltIns") + @TestDataPath("$PROJECT_ROOT") + public class TargetedBuiltIns { + @Test + public void testAllFilesPresentInTargetedBuiltIns() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/targetedBuiltIns"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("blackListed.kt") + public void testBlackListed() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/targetedBuiltIns/blackListed.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/trailingComma") + @TestDataPath("$PROJECT_ROOT") + public class TrailingComma { + @Test + public void testAllFilesPresentInTrailingComma() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/trailingComma"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("multiVariableDeclarationWithDisabledFeature.kt") + public void testMultiVariableDeclarationWithDisabledFeature() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/trailingComma/multiVariableDeclarationWithDisabledFeature.kt"); + } + + @Test + @TestMetadata("multiVariableDeclarationWithEnabledFeature.kt") + public void testMultiVariableDeclarationWithEnabledFeature() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/trailingComma/multiVariableDeclarationWithEnabledFeature.kt"); + } + + @Test + @TestMetadata("noDisambiguation.kt") + public void testNoDisambiguation() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/trailingComma/noDisambiguation.kt"); + } + + @Test + @TestMetadata("typeArgumentsWithDisabledFeature.kt") + public void testTypeArgumentsWithDisabledFeature() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/trailingComma/typeArgumentsWithDisabledFeature.kt"); + } + + @Test + @TestMetadata("typeArgumentsWithEnabledFeature.kt") + public void testTypeArgumentsWithEnabledFeature() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/trailingComma/typeArgumentsWithEnabledFeature.kt"); + } + + @Test + @TestMetadata("typeParametersWithDisabledFeature.kt") + public void testTypeParametersWithDisabledFeature() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/trailingComma/typeParametersWithDisabledFeature.kt"); + } + + @Test + @TestMetadata("typeParametersWithEnabledFeature.kt") + public void testTypeParametersWithEnabledFeature() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/trailingComma/typeParametersWithEnabledFeature.kt"); + } + + @Test + @TestMetadata("valueArgumentsWithDisabledFeature.kt") + public void testValueArgumentsWithDisabledFeature() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/trailingComma/valueArgumentsWithDisabledFeature.kt"); + } + + @Test + @TestMetadata("valueArgumentsWithEnabledFeature.kt") + public void testValueArgumentsWithEnabledFeature() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/trailingComma/valueArgumentsWithEnabledFeature.kt"); + } + + @Test + @TestMetadata("valueParametersWithDisabledFeature.kt") + public void testValueParametersWithDisabledFeature() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/trailingComma/valueParametersWithDisabledFeature.kt"); + } + + @Test + @TestMetadata("valueParametersWithEnabledFeature.kt") + public void testValueParametersWithEnabledFeature() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/trailingComma/valueParametersWithEnabledFeature.kt"); + } + + @Test + @TestMetadata("whenEntryWithDisabledFeature.kt") + public void testWhenEntryWithDisabledFeature() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/trailingComma/whenEntryWithDisabledFeature.kt"); + } + + @Test + @TestMetadata("whenEntryWithEnabledFeature.kt") + public void testWhenEntryWithEnabledFeature() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/trailingComma/whenEntryWithEnabledFeature.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/tryCatch") + @TestDataPath("$PROJECT_ROOT") + public class TryCatch { + @Test + public void testAllFilesPresentInTryCatch() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/tryCatch"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("assignTry.kt") + public void testAssignTry() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/tryCatch/assignTry.kt"); + } + + @Test + @TestMetadata("boundedSmartcasts.kt") + public void testBoundedSmartcasts() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/tryCatch/boundedSmartcasts.kt"); + } + + @Test + @TestMetadata("catchRedeclaration.kt") + public void testCatchRedeclaration() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/tryCatch/catchRedeclaration.kt"); + } + + @Test + @TestMetadata("correctSmartcasts.kt") + public void testCorrectSmartcasts() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/tryCatch/correctSmartcasts.kt"); + } + + @Test + @TestMetadata("correctSmartcasts_after.kt") + public void testCorrectSmartcasts_after() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/tryCatch/correctSmartcasts_after.kt"); + } + + @Test + @TestMetadata("falseNegativeSmartcasts.kt") + public void testFalseNegativeSmartcasts() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/tryCatch/falseNegativeSmartcasts.kt"); + } + + @Test + @TestMetadata("falseNegativeSmartcasts_after.kt") + public void testFalseNegativeSmartcasts_after() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/tryCatch/falseNegativeSmartcasts_after.kt"); + } + + @Test + @TestMetadata("falsePositiveSmartcasts.kt") + public void testFalsePositiveSmartcasts() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/tryCatch/falsePositiveSmartcasts.kt"); + } + + @Test + @TestMetadata("falsePositiveSmartcasts_after.kt") + public void testFalsePositiveSmartcasts_after() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/tryCatch/falsePositiveSmartcasts_after.kt"); + } + + @Test + @TestMetadata("tryExpression.kt") + public void testTryExpression() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/tryCatch/tryExpression.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/typealias") + @TestDataPath("$PROJECT_ROOT") + public class Typealias { + @Test + public void testAllFilesPresentInTypealias() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/typealias"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("exceptionTypeAliases.kt") + public void testExceptionTypeAliases() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/typealias/exceptionTypeAliases.kt"); + } + + @Test + @TestMetadata("exceptionTypeAliasesInvisibleWithApiVersion1_0.kt") + public void testExceptionTypeAliasesInvisibleWithApiVersion1_0() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/typealias/exceptionTypeAliasesInvisibleWithApiVersion1_0.kt"); + } + + @Test + @TestMetadata("hashMapTypeAlias.kt") + public void testHashMapTypeAlias() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/typealias/hashMapTypeAlias.kt"); + } + + @Test + @TestMetadata("typeAliasSamAdapterConstructors.kt") + public void testTypeAliasSamAdapterConstructors() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/typealias/typeAliasSamAdapterConstructors.kt"); + } + + @Test + @TestMetadata("typeAliasSamAdapterConstructors2.kt") + public void testTypeAliasSamAdapterConstructors2() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/typealias/typeAliasSamAdapterConstructors2.kt"); + } + + @Test + @TestMetadata("upperBoundViolated.kt") + public void testUpperBoundViolated() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/typealias/upperBoundViolated.kt"); + } + + @Test + @TestMetadata("upperBoundViolated2.kt") + public void testUpperBoundViolated2() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/typealias/upperBoundViolated2.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/varargs") + @TestDataPath("$PROJECT_ROOT") + public class Varargs { + @Test + public void testAllFilesPresentInVarargs() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/varargs"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("kt3213.kt") + public void testKt3213() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/varargs/kt3213.kt"); + } + + @Test + @TestMetadata("kt4172j.kt") + public void testKt4172j() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/varargs/kt4172j.kt"); + } + + @Test + @TestMetadata("kt5534.kt") + public void testKt5534() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/varargs/kt5534.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/when") + @TestDataPath("$PROJECT_ROOT") + public class When { + @Test + public void testAllFilesPresentInWhen() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/when"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Test + @TestMetadata("kt10192.kt") + public void testKt10192() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/when/kt10192.kt"); + } + + @Test + @TestMetadata("kt10807.kt") + public void testKt10807() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/when/kt10807.kt"); + } + + @Test + @TestMetadata("noTypeArgumentsInConstructor.kt") + public void testNoTypeArgumentsInConstructor() throws Exception { + runTest("compiler/testData/diagnostics/testsWithStdLib/when/noTypeArgumentsInConstructor.kt"); + } + } + } +} diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirPreresolvedReversedDiagnosticCompilerFirTestDataTestGenerated.java b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirPreresolvedReversedDiagnosticCompilerFirTestDataTestGenerated.java new file mode 100644 index 00000000000..f98d0fd9247 --- /dev/null +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirPreresolvedReversedDiagnosticCompilerFirTestDataTestGenerated.java @@ -0,0 +1,7007 @@ +/* + * 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.analysis.low.level.api.fir.diagnostic.compiler.based; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +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.analysis.api.GenerateAnalysisApiTestsKt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +public class LLFirPreresolvedReversedDiagnosticCompilerFirTestDataTestGenerated extends AbstractLLFirPreresolvedReversedDiagnosticCompilerTestDataTest { + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve") + @TestDataPath("$PROJECT_ROOT") + public class Resolve { + @Test + public void testAllFilesPresentInResolve() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("annotationOnDeclarationWithDifferentArguments.kt") + public void testAnnotationOnDeclarationWithDifferentArguments() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/annotationOnDeclarationWithDifferentArguments.kt"); + } + + @Test + @TestMetadata("annotationOnGetClassCall.kt") + public void testAnnotationOnGetClassCall() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/annotationOnGetClassCall.kt"); + } + + @Test + @TestMetadata("annotationUsedAsAnnotationArgument.kt") + public void testAnnotationUsedAsAnnotationArgument() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/annotationUsedAsAnnotationArgument.kt"); + } + + @Test + @TestMetadata("asImports.kt") + public void testAsImports() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/asImports.kt"); + } + + @Test + @TestMetadata("bareTypes.kt") + public void testBareTypes() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/bareTypes.kt"); + } + + @Test + @TestMetadata("bareTypes2.kt") + public void testBareTypes2() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/bareTypes2.kt"); + } + + @Test + @TestMetadata("bareTypesWithFlexibleArguments.kt") + public void testBareTypesWithFlexibleArguments() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/bareTypesWithFlexibleArguments.kt"); + } + + @Test + @TestMetadata("cast.kt") + public void testCast() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cast.kt"); + } + + @Test + @TestMetadata("catchParameter.kt") + public void testCatchParameter() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/catchParameter.kt"); + } + + @Test + @TestMetadata("classCallInLambda.kt") + public void testClassCallInLambda() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/classCallInLambda.kt"); + } + + @Test + @TestMetadata("companion.kt") + public void testCompanion() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/companion.kt"); + } + + @Test + @TestMetadata("companionAccessInEnum.kt") + public void testCompanionAccessInEnum() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/companionAccessInEnum.kt"); + } + + @Test + @TestMetadata("companionObjectCall.kt") + public void testCompanionObjectCall() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/companionObjectCall.kt"); + } + + @Test + @TestMetadata("companionUsesNested.kt") + public void testCompanionUsesNested() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/companionUsesNested.kt"); + } + + @Test + @TestMetadata("constantValues.kt") + public void testConstantValues() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/constantValues.kt"); + } + + @Test + @TestMetadata("copy.kt") + public void testCopy() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/copy.kt"); + } + + @Test + @TestMetadata("covariantArrayAsReceiver.kt") + public void testCovariantArrayAsReceiver() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/covariantArrayAsReceiver.kt"); + } + + @Test + @TestMetadata("defaultJavaImportHiding.kt") + public void testDefaultJavaImportHiding() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/defaultJavaImportHiding.kt"); + } + + @Test + @TestMetadata("defaultParametersInheritedToJava.kt") + public void testDefaultParametersInheritedToJava() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/defaultParametersInheritedToJava.kt"); + } + + @Test + @TestMetadata("definitelyNotNullAmbiguity.kt") + public void testDefinitelyNotNullAmbiguity() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/definitelyNotNullAmbiguity.kt"); + } + + @Test + @TestMetadata("delegatedSuperType.kt") + public void testDelegatedSuperType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/delegatedSuperType.kt"); + } + + @Test + @TestMetadata("delegatingConstructorCall.kt") + public void testDelegatingConstructorCall() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/delegatingConstructorCall.kt"); + } + + @Test + @TestMetadata("delegatingConstructorsAndTypeAliases.kt") + public void testDelegatingConstructorsAndTypeAliases() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/delegatingConstructorsAndTypeAliases.kt"); + } + + @Test + @TestMetadata("derivedClass.kt") + public void testDerivedClass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/derivedClass.kt"); + } + + @Test + @TestMetadata("elvisReturnSimple.kt") + public void testElvisReturnSimple() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/elvisReturnSimple.kt"); + } + + @Test + @TestMetadata("enum.kt") + public void testEnum() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/enum.kt"); + } + + @Test + @TestMetadata("enumWithCompanion.kt") + public void testEnumWithCompanion() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/enumWithCompanion.kt"); + } + + @Test + @TestMetadata("extension.kt") + public void testExtension() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extension.kt"); + } + + @Test + @TestMetadata("F.kt") + public void testF() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/F.kt"); + } + + @Test + @TestMetadata("fakeRecursiveSupertype.kt") + public void testFakeRecursiveSupertype() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/fakeRecursiveSupertype.kt"); + } + + @Test + @TestMetadata("fakeRecursiveTypealias.kt") + public void testFakeRecursiveTypealias() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/fakeRecursiveTypealias.kt"); + } + + @Test + @TestMetadata("fib.kt") + public void testFib() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/fib.kt"); + } + + @Test + @TestMetadata("flexibleCapturedType.kt") + public void testFlexibleCapturedType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/flexibleCapturedType.kt"); + } + + @Test + @TestMetadata("ft.kt") + public void testFt() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/ft.kt"); + } + + @Test + @TestMetadata("funInterfaceDeclaration.kt") + public void testFunInterfaceDeclaration() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/funInterfaceDeclaration.kt"); + } + + @Test + @TestMetadata("functionTypeAlias.kt") + public void testFunctionTypeAlias() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/functionTypeAlias.kt"); + } + + @Test + @TestMetadata("functionTypes.kt") + public void testFunctionTypes() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/functionTypes.kt"); + } + + @Test + @TestMetadata("genericConstructors.kt") + public void testGenericConstructors() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/genericConstructors.kt"); + } + + @Test + @TestMetadata("genericFunctions.kt") + public void testGenericFunctions() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/genericFunctions.kt"); + } + + @Test + @TestMetadata("genericReceiverPropertyOverride.kt") + public void testGenericReceiverPropertyOverride() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/genericReceiverPropertyOverride.kt"); + } + + @Test + @TestMetadata("implicitTypeFromOtherModule.kt") + public void testImplicitTypeFromOtherModule() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/implicitTypeFromOtherModule.kt"); + } + + @Test + @TestMetadata("implicitTypeInFakeOverride.kt") + public void testImplicitTypeInFakeOverride() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/implicitTypeInFakeOverride.kt"); + } + + @Test + @TestMetadata("implicitTypeIntersectionOverrideFromOtherModule.kt") + public void testImplicitTypeIntersectionOverrideFromOtherModule() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/implicitTypeIntersectionOverrideFromOtherModule.kt"); + } + + @Test + @TestMetadata("implicitTypeSubstituteOverrideFromOtherModule.kt") + public void testImplicitTypeSubstituteOverrideFromOtherModule() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/implicitTypeSubstituteOverrideFromOtherModule.kt"); + } + + @Test + @TestMetadata("implicitTypeSubstituteOverrideInNestedClassFromOtherModule.kt") + public void testImplicitTypeSubstituteOverrideInNestedClassFromOtherModule() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/implicitTypeSubstituteOverrideInNestedClassFromOtherModule.kt"); + } + + @Test + @TestMetadata("implicitTypeWithTypeBound.kt") + public void testImplicitTypeWithTypeBound() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/implicitTypeWithTypeBound.kt"); + } + + @Test + @TestMetadata("incorrectDataClass.kt") + public void testIncorrectDataClass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/incorrectDataClass.kt"); + } + + @Test + @TestMetadata("incorrectSuperCall.kt") + public void testIncorrectSuperCall() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/incorrectSuperCall.kt"); + } + + @Test + @TestMetadata("inherentlyImportedTypeFromOtherModule.kt") + public void testInherentlyImportedTypeFromOtherModule() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inherentlyImportedTypeFromOtherModule.kt"); + } + + @Test + @TestMetadata("inherentlyImportedTypeFromOtherModule2.kt") + public void testInherentlyImportedTypeFromOtherModule2() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inherentlyImportedTypeFromOtherModule2.kt"); + } + + @Test + @TestMetadata("inherentlyImportedTypeFromOtherModule3.kt") + public void testInherentlyImportedTypeFromOtherModule3() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inherentlyImportedTypeFromOtherModule3.kt"); + } + + @Test + @TestMetadata("intersectionScope.kt") + public void testIntersectionScope() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/intersectionScope.kt"); + } + + @Test + @TestMetadata("intersectionTypes.kt") + public void testIntersectionTypes() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/intersectionTypes.kt"); + } + + @Test + @TestMetadata("invokeInWhenSubjectVariableInitializer.kt") + public void testInvokeInWhenSubjectVariableInitializer() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/invokeInWhenSubjectVariableInitializer.kt"); + } + + @Test + @TestMetadata("invokeOfLambdaWithReceiver.kt") + public void testInvokeOfLambdaWithReceiver() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/invokeOfLambdaWithReceiver.kt"); + } + + @Test + @TestMetadata("javaFieldVsAccessor.kt") + public void testJavaFieldVsAccessor() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/javaFieldVsAccessor.kt"); + } + + @Test + @TestMetadata("javaStaticScopeInheritance.kt") + public void testJavaStaticScopeInheritance() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/javaStaticScopeInheritance.kt"); + } + + @Test + @TestMetadata("kt41984.kt") + public void testKt41984() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/kt41984.kt"); + } + + @Test + @TestMetadata("kt41990.kt") + public void testKt41990() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/kt41990.kt"); + } + + @Test + @TestMetadata("kt54220.kt") + public void testKt54220() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/kt54220.kt"); + } + + @Test + @TestMetadata("kt54775.kt") + public void testKt54775() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/kt54775.kt"); + } + + @Test + @TestMetadata("labelAndReceiverForInfix.kt") + public void testLabelAndReceiverForInfix() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/labelAndReceiverForInfix.kt"); + } + + @Test + @TestMetadata("labeledReturnFromNotLabeledUnnamedFunction.kt") + public void testLabeledReturnFromNotLabeledUnnamedFunction() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/labeledReturnFromNotLabeledUnnamedFunction.kt"); + } + + @Test + @TestMetadata("lambdaArgInScopeFunction.kt") + public void testLambdaArgInScopeFunction() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/lambdaArgInScopeFunction.kt"); + } + + @Test + @TestMetadata("lambdaInLhsOfTypeOperatorCall.kt") + public void testLambdaInLhsOfTypeOperatorCall() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/lambdaInLhsOfTypeOperatorCall.kt"); + } + + @Test + @TestMetadata("lambdaPropertyTypeInference.kt") + public void testLambdaPropertyTypeInference() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/lambdaPropertyTypeInference.kt"); + } + + @Test + @TestMetadata("localFunctionsHiding.kt") + public void testLocalFunctionsHiding() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/localFunctionsHiding.kt"); + } + + @Test + @TestMetadata("localObject.kt") + public void testLocalObject() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/localObject.kt"); + } + + @Test + @TestMetadata("nestedAnnotationConstExprArguments.kt") + public void testNestedAnnotationConstExprArguments() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/nestedAnnotationConstExprArguments.kt"); + } + + @Test + @TestMetadata("nestedClass.kt") + public void testNestedClass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/nestedClass.kt"); + } + + @Test + @TestMetadata("nestedClassContructor.kt") + public void testNestedClassContructor() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/nestedClassContructor.kt"); + } + + @Test + @TestMetadata("nestedClassNameClash.kt") + public void testNestedClassNameClash() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/nestedClassNameClash.kt"); + } + + @Test + @TestMetadata("NestedOfAliasedType.kt") + public void testNestedOfAliasedType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/NestedOfAliasedType.kt"); + } + + @Test + @TestMetadata("nestedReturnType.kt") + public void testNestedReturnType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/nestedReturnType.kt"); + } + + @Test + @TestMetadata("NestedSuperType.kt") + public void testNestedSuperType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/NestedSuperType.kt"); + } + + @Test + @TestMetadata("objectInnerClass.kt") + public void testObjectInnerClass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/objectInnerClass.kt"); + } + + @Test + @TestMetadata("offOrderMultiBoundGenericOverride.kt") + public void testOffOrderMultiBoundGenericOverride() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/offOrderMultiBoundGenericOverride.kt"); + } + + @Test + @TestMetadata("openInInterface.kt") + public void testOpenInInterface() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/openInInterface.kt"); + } + + @Test + @TestMetadata("problems2.kt") + public void testProblems2() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems2.kt"); + } + + @Test + @TestMetadata("propertyFromJavaPlusAssign.kt") + public void testPropertyFromJavaPlusAssign() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/propertyFromJavaPlusAssign.kt"); + } + + @Test + @TestMetadata("qualifierWithCompanion.kt") + public void testQualifierWithCompanion() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/qualifierWithCompanion.kt"); + } + + @Test + @TestMetadata("rawTypeSam.kt") + public void testRawTypeSam() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/rawTypeSam.kt"); + } + + @Test + @TestMetadata("recursiveCallOnWhenWithSealedClass.kt") + public void testRecursiveCallOnWhenWithSealedClass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/recursiveCallOnWhenWithSealedClass.kt"); + } + + @Test + @TestMetadata("recursiveTypeAlias.kt") + public void testRecursiveTypeAlias() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/recursiveTypeAlias.kt"); + } + + @Test + @TestMetadata("reifiedTypeOverload.kt") + public void testReifiedTypeOverload() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/reifiedTypeOverload.kt"); + } + + @Test + @TestMetadata("returnFromDelegatedConstuctor.kt") + public void testReturnFromDelegatedConstuctor() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/returnFromDelegatedConstuctor.kt"); + } + + @Test + @TestMetadata("sealedClass.kt") + public void testSealedClass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/sealedClass.kt"); + } + + @Test + @TestMetadata("settersGetters.kt") + public void testSettersGetters() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/settersGetters.kt"); + } + + @Test + @TestMetadata("simpleClass.kt") + public void testSimpleClass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/simpleClass.kt"); + } + + @Test + @TestMetadata("simpleTypeAlias.kt") + public void testSimpleTypeAlias() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/simpleTypeAlias.kt"); + } + + @Test + @TestMetadata("spreadOperator.kt") + public void testSpreadOperator() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/spreadOperator.kt"); + } + + @Test + @TestMetadata("statusResolveForTypealiasAsSuperClass.kt") + public void testStatusResolveForTypealiasAsSuperClass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/statusResolveForTypealiasAsSuperClass.kt"); + } + + @Test + @TestMetadata("supertypesForAnnotationClass.kt") + public void testSupertypesForAnnotationClass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/supertypesForAnnotationClass.kt"); + } + + @Test + @TestMetadata("syntheticsVsNormalProperties.kt") + public void testSyntheticsVsNormalProperties() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/syntheticsVsNormalProperties.kt"); + } + + @Test + @TestMetadata("throwableSubclass.kt") + public void testThrowableSubclass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/throwableSubclass.kt"); + } + + @Test + @TestMetadata("topLevelDestruction.kt") + public void testTopLevelDestruction() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/topLevelDestruction.kt"); + } + + @Test + @TestMetadata("treeSet.kt") + public void testTreeSet() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/treeSet.kt"); + } + + @Test + @TestMetadata("tryInference.kt") + public void testTryInference() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/tryInference.kt"); + } + + @Test + @TestMetadata("TwoDeclarationsInSameFile.kt") + public void testTwoDeclarationsInSameFile() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/TwoDeclarationsInSameFile.kt"); + } + + @Test + @TestMetadata("typeAliasWithGeneric.kt") + public void testTypeAliasWithGeneric() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/typeAliasWithGeneric.kt"); + } + + @Test + @TestMetadata("typeAliasWithTypeArguments.kt") + public void testTypeAliasWithTypeArguments() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/typeAliasWithTypeArguments.kt"); + } + + @Test + @TestMetadata("typeFromGetter.kt") + public void testTypeFromGetter() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/typeFromGetter.kt"); + } + + @Test + @TestMetadata("typeParameterInBoundsLocalFunction.kt") + public void testTypeParameterInBoundsLocalFunction() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/typeParameterInBoundsLocalFunction.kt"); + } + + @Test + @TestMetadata("typeParameterInPropertyReceiver.kt") + public void testTypeParameterInPropertyReceiver() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/typeParameterInPropertyReceiver.kt"); + } + + @Test + @TestMetadata("typeParameterVsNested.kt") + public void testTypeParameterVsNested() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/typeParameterVsNested.kt"); + } + + @Test + @TestMetadata("typesInLocalFunctions.kt") + public void testTypesInLocalFunctions() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/typesInLocalFunctions.kt"); + } + + @Test + @TestMetadata("unitTypeFromOtherModule.kt") + public void testUnitTypeFromOtherModule() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/unitTypeFromOtherModule.kt"); + } + + @Test + @TestMetadata("unitTypeSubstituteOverrideInNestedClassFromOtherModule.kt") + public void testUnitTypeSubstituteOverrideInNestedClassFromOtherModule() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/unitTypeSubstituteOverrideInNestedClassFromOtherModule.kt"); + } + + @Test + @TestMetadata("varargInPrimaryConstructor.kt") + public void testVarargInPrimaryConstructor() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/varargInPrimaryConstructor.kt"); + } + + @Test + @TestMetadata("visibleVsInvisibleQualifier.kt") + public void testVisibleVsInvisibleQualifier() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/visibleVsInvisibleQualifier.kt"); + } + + @Test + @TestMetadata("whenAsReceiver.kt") + public void testWhenAsReceiver() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/whenAsReceiver.kt"); + } + + @Test + @TestMetadata("whenElse.kt") + public void testWhenElse() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/whenElse.kt"); + } + + @Test + @TestMetadata("whenExpressionType.kt") + public void testWhenExpressionType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/whenExpressionType.kt"); + } + + @Test + @TestMetadata("whenInference.kt") + public void testWhenInference() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/whenInference.kt"); + } + + @Test + @TestMetadata("whenWithWhenAsStatement.kt") + public void testWhenWithWhenAsStatement() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/whenWithWhenAsStatement.kt"); + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/annotations") + @TestDataPath("$PROJECT_ROOT") + public class Annotations { + @Test + public void testAllFilesPresentInAnnotations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/annotations"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("kt43936.kt") + public void testKt43936() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/annotations/kt43936.kt"); + } + + @Test + @TestMetadata("kt54478.kt") + public void testKt54478() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/annotations/kt54478.kt"); + } + + @Test + @TestMetadata("kt55286.kt") + public void testKt55286() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/annotations/kt55286.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/arguments") + @TestDataPath("$PROJECT_ROOT") + public class Arguments { + @Test + public void testAllFilesPresentInArguments() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/arguments"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("ambiguityOnJavaOverride.kt") + public void testAmbiguityOnJavaOverride() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.kt"); + } + + @Test + @TestMetadata("argParamTypeMismatch.kt") + public void testArgParamTypeMismatch() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/argParamTypeMismatch.kt"); + } + + @Test + @TestMetadata("argumentsOfAnnotations.kt") + public void testArgumentsOfAnnotations() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/argumentsOfAnnotations.kt"); + } + + @Test + @TestMetadata("argumentsOfJavaAnnotation.kt") + public void testArgumentsOfJavaAnnotation() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/argumentsOfJavaAnnotation.kt"); + } + + @Test + @TestMetadata("default.kt") + public void testDefault() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/default.kt"); + } + + @Test + @TestMetadata("defaultFromOverrides.kt") + public void testDefaultFromOverrides() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/defaultFromOverrides.kt"); + } + + @Test + @TestMetadata("definetelyNotNullForTypeParameter.kt") + public void testDefinetelyNotNullForTypeParameter() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/definetelyNotNullForTypeParameter.kt"); + } + + @Test + @TestMetadata("destructuring.kt") + public void testDestructuring() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/destructuring.kt"); + } + + @Test + @TestMetadata("extensionLambdaInDefaultArgument.kt") + public void testExtensionLambdaInDefaultArgument() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/extensionLambdaInDefaultArgument.kt"); + } + + @Test + @TestMetadata("fieldPlusAssign.kt") + public void testFieldPlusAssign() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/fieldPlusAssign.kt"); + } + + @Test + @TestMetadata("incorrectFunctionalType.kt") + public void testIncorrectFunctionalType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/incorrectFunctionalType.kt"); + } + + @Test + @TestMetadata("integerLiteralTypes.kt") + public void testIntegerLiteralTypes() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/integerLiteralTypes.kt"); + } + + @Test + @TestMetadata("integerOverloads.kt") + public void testIntegerOverloads() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/integerOverloads.kt"); + } + + @Test + @TestMetadata("invoke.kt") + public void testInvoke() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/invoke.kt"); + } + + @Test + @TestMetadata("javaAnnotationsWithArrayValue.kt") + public void testJavaAnnotationsWithArrayValue() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/javaAnnotationsWithArrayValue.kt"); + } + + @Test + @TestMetadata("javaArrayVariance.kt") + public void testJavaArrayVariance() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/javaArrayVariance.kt"); + } + + @Test + @TestMetadata("kt41940.kt") + public void testKt41940() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/kt41940.kt"); + } + + @Test + @TestMetadata("lambda.kt") + public void testLambda() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/lambda.kt"); + } + + @Test + @TestMetadata("lambdaInLambda.kt") + public void testLambdaInLambda() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInLambda.kt"); + } + + @Test + @TestMetadata("lambdaInLambda2.kt") + public void testLambdaInLambda2() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInLambda2.kt"); + } + + @Test + @TestMetadata("lambdaInUnresolvedCall.kt") + public void testLambdaInUnresolvedCall() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInUnresolvedCall.kt"); + } + + @Test + @TestMetadata("namedArrayInAnnotation.kt") + public void testNamedArrayInAnnotation() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/namedArrayInAnnotation.kt"); + } + + @Test + @TestMetadata("nestedClassInAnnotationArgument.kt") + public void testNestedClassInAnnotationArgument() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/nestedClassInAnnotationArgument.kt"); + } + + @Test + @TestMetadata("noParameterForName.kt") + public void testNoParameterForName() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/noParameterForName.kt"); + } + + @Test + @TestMetadata("nullForDifferentProjections.kt") + public void testNullForDifferentProjections() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/nullForDifferentProjections.kt"); + } + + @Test + @TestMetadata("operatorsOverLiterals.kt") + public void testOperatorsOverLiterals() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/operatorsOverLiterals.kt"); + } + + @Test + @TestMetadata("overloadByReceiver.kt") + public void testOverloadByReceiver() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/overloadByReceiver.kt"); + } + + @Test + @TestMetadata("overloadWithDefault.kt") + public void testOverloadWithDefault() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/overloadWithDefault.kt"); + } + + @Test + @TestMetadata("setWithTrailingLambda.kt") + public void testSetWithTrailingLambda() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/setWithTrailingLambda.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/simple.kt"); + } + + @Test + @TestMetadata("stringTemplates.kt") + public void testStringTemplates() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/stringTemplates.kt"); + } + + @Test + @TestMetadata("tryInLambda.kt") + public void testTryInLambda() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/tryInLambda.kt"); + } + + @Test + @TestMetadata("typeMismatchOnExpectedJavaMap.kt") + public void testTypeMismatchOnExpectedJavaMap() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/typeMismatchOnExpectedJavaMap.kt"); + } + + @Test + @TestMetadata("untouchedReturnInIf.kt") + public void testUntouchedReturnInIf() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/untouchedReturnInIf.kt"); + } + + @Test + @TestMetadata("vararg.kt") + public void testVararg() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/vararg.kt"); + } + + @Test + @TestMetadata("varargFromJava.kt") + public void testVarargFromJava() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/varargFromJava.kt"); + } + + @Test + @TestMetadata("varargOfLambdasWithReceiver.kt") + public void testVarargOfLambdasWithReceiver() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/varargOfLambdasWithReceiver.kt"); + } + + @Test + @TestMetadata("varargProjection.kt") + public void testVarargProjection() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arguments/varargProjection.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/arrays") + @TestDataPath("$PROJECT_ROOT") + public class Arrays { + @Test + public void testAllFilesPresentInArrays() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/arrays"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("arraySet.kt") + public void testArraySet() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arrays/arraySet.kt"); + } + + @Test + @TestMetadata("arraySetWithOperation.kt") + public void testArraySetWithOperation() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/arrays/arraySetWithOperation.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/builtins") + @TestDataPath("$PROJECT_ROOT") + public class Builtins { + @Test + public void testAllFilesPresentInBuiltins() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/builtins"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("lists.kt") + public void testLists() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/builtins/lists.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/callResolution") + @TestDataPath("$PROJECT_ROOT") + public class CallResolution { + @Test + public void testAllFilesPresentInCallResolution() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/callResolution"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("arraySetWithPlusAssign.kt") + public void testArraySetWithPlusAssign() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/arraySetWithPlusAssign.kt"); + } + + @Test + @TestMetadata("chooseOverloadByShapeOfLambda.kt") + public void testChooseOverloadByShapeOfLambda() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/chooseOverloadByShapeOfLambda.kt"); + } + + @Test + @TestMetadata("companionInvoke.kt") + public void testCompanionInvoke() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/companionInvoke.kt"); + } + + @Test + @TestMetadata("companionVsSuperStatic.kt") + public void testCompanionVsSuperStatic() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/companionVsSuperStatic.kt"); + } + + @Test + @TestMetadata("debugExpressionType.kt") + public void testDebugExpressionType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/debugExpressionType.kt"); + } + + @Test + @TestMetadata("debugInfoCall.kt") + public void testDebugInfoCall() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/debugInfoCall.kt"); + } + + @Test + @TestMetadata("errorCandidates.kt") + public void testErrorCandidates() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/errorCandidates.kt"); + } + + @Test + @TestMetadata("exponentialArraySetWithPlusAssign.kt") + public void testExponentialArraySetWithPlusAssign() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/exponentialArraySetWithPlusAssign.kt"); + } + + @Test + @TestMetadata("extensionInvokeAfterSafeCall.kt") + public void testExtensionInvokeAfterSafeCall() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/extensionInvokeAfterSafeCall.kt"); + } + + @Test + @TestMetadata("incorrectPlusOperatorFromJava.kt") + public void testIncorrectPlusOperatorFromJava() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/incorrectPlusOperatorFromJava.kt"); + } + + @Test + @TestMetadata("invokeAmbiguity.kt") + public void testInvokeAmbiguity() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/invokeAmbiguity.kt"); + } + + @Test + @TestMetadata("invokeWithReceiverAndArgument.kt") + public void testInvokeWithReceiverAndArgument() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/invokeWithReceiverAndArgument.kt"); + } + + @Test + @TestMetadata("kt37056.kt") + public void testKt37056() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/kt37056.kt"); + } + + @Test + @TestMetadata("kt50386.kt") + public void testKt50386() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/kt50386.kt"); + } + + @Test + @TestMetadata("lambdaAsReceiver.kt") + public void testLambdaAsReceiver() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/lambdaAsReceiver.kt"); + } + + @Test + @TestMetadata("objectInvoke.kt") + public void testObjectInvoke() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/objectInvoke.kt"); + } + + @Test + @TestMetadata("overloadsWithGenericAndGenericLambda.kt") + public void testOverloadsWithGenericAndGenericLambda() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/overloadsWithGenericAndGenericLambda.kt"); + } + + @Test + @TestMetadata("referenceToNestedClass.kt") + public void testReferenceToNestedClass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/referenceToNestedClass.kt"); + } + + @Test + @TestMetadata("safeCallOnTypeAlias.kt") + public void testSafeCallOnTypeAlias() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/safeCallOnTypeAlias.kt"); + } + + @Test + @TestMetadata("superAny.kt") + public void testSuperAny() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/superAny.kt"); + } + + @Test + @TestMetadata("suspendCOnversionForReceiver.kt") + public void testSuspendCOnversionForReceiver() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/suspendCOnversionForReceiver.kt"); + } + + @Test + @TestMetadata("syntheticPropertiesWrongImplicitReceiver.kt") + public void testSyntheticPropertiesWrongImplicitReceiver() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/syntheticPropertiesWrongImplicitReceiver.kt"); + } + + @Test + @TestMetadata("twoLocalLambdasWithSameName.kt") + public void testTwoLocalLambdasWithSameName() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/twoLocalLambdasWithSameName.kt"); + } + + @Test + @TestMetadata("typeAliasWithNotNullBound.kt") + public void testTypeAliasWithNotNullBound() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/typeAliasWithNotNullBound.kt"); + } + + @Test + @TestMetadata("uselessMultipleBounds.kt") + public void testUselessMultipleBounds() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/uselessMultipleBounds.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/cfa") + @TestDataPath("$PROJECT_ROOT") + public class Cfa { + @Test + public void testAllFilesPresentInCfa() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/cfa"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("initializationInTry.kt") + public void testInitializationInTry() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfa/initializationInTry.kt"); + } + + @Test + @TestMetadata("kt53819.kt") + public void testKt53819() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfa/kt53819.kt"); + } + + @Test + @TestMetadata("reassignOfNonLocalProperty_initializedProperties.kt") + public void testReassignOfNonLocalProperty_initializedProperties() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfa/reassignOfNonLocalProperty_initializedProperties.kt"); + } + + @Test + @TestMetadata("reassignOfNonMemberProperty_lateInitialization.kt") + public void testReassignOfNonMemberProperty_lateInitialization() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfa/reassignOfNonMemberProperty_lateInitialization.kt"); + } + + @Test + @TestMetadata("smartcastOnThisDuringClassInitialization.kt") + public void testSmartcastOnThisDuringClassInitialization() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfa/smartcastOnThisDuringClassInitialization.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/cfg") + @TestDataPath("$PROJECT_ROOT") + public class Cfg { + @Test + public void testAllFilesPresentInCfg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/cfg"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("annotatedLocalClass.kt") + public void testAnnotatedLocalClass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/annotatedLocalClass.kt"); + } + + @Test + @TestMetadata("anonymousObjectInUnreachableCode.kt") + public void testAnonymousObjectInUnreachableCode() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/anonymousObjectInUnreachableCode.kt"); + } + + @Test + @TestMetadata("binaryOperations.kt") + public void testBinaryOperations() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/binaryOperations.kt"); + } + + @Test + @TestMetadata("booleanOperatorsWithConsts.kt") + public void testBooleanOperatorsWithConsts() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/booleanOperatorsWithConsts.kt"); + } + + @Test + @TestMetadata("complex.kt") + public void testComplex() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/complex.kt"); + } + + @Test + @TestMetadata("defaultArguments.kt") + public void testDefaultArguments() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/defaultArguments.kt"); + } + + @Test + @TestMetadata("emptyWhen.kt") + public void testEmptyWhen() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/emptyWhen.kt"); + } + + @Test + @TestMetadata("flowFromInplaceLambda.kt") + public void testFlowFromInplaceLambda() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/flowFromInplaceLambda.kt"); + } + + @Test + @TestMetadata("flowFromInplaceLambda2.kt") + public void testFlowFromInplaceLambda2() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/flowFromInplaceLambda2.kt"); + } + + @Test + @TestMetadata("flowFromInplaceLambda3.kt") + public void testFlowFromInplaceLambda3() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/flowFromInplaceLambda3.kt"); + } + + @Test + @TestMetadata("flowFromTwoInplaceLambdas.kt") + public void testFlowFromTwoInplaceLambdas() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/flowFromTwoInplaceLambdas.kt"); + } + + @Test + @TestMetadata("initBlock.kt") + public void testInitBlock() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/initBlock.kt"); + } + + @Test + @TestMetadata("initBlockAndInPlaceLambda.kt") + public void testInitBlockAndInPlaceLambda() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/initBlockAndInPlaceLambda.kt"); + } + + @Test + @TestMetadata("inlineLambdasAreInplace.kt") + public void testInlineLambdasAreInplace() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/inlineLambdasAreInplace.kt"); + } + + @Test + @TestMetadata("innerClassInAnonymousObject.kt") + public void testInnerClassInAnonymousObject() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/innerClassInAnonymousObject.kt"); + } + + @Test + @TestMetadata("inplaceLambdaInControlFlowExpressions.kt") + public void testInplaceLambdaInControlFlowExpressions() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/inplaceLambdaInControlFlowExpressions.kt"); + } + + @Test + @TestMetadata("jumps.kt") + public void testJumps() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/jumps.kt"); + } + + @Test + @TestMetadata("lambdaAsReturnOfLambda.kt") + public void testLambdaAsReturnOfLambda() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/lambdaAsReturnOfLambda.kt"); + } + + @Test + @TestMetadata("lambdaInIfInTry.kt") + public void testLambdaInIfInTry() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/lambdaInIfInTry.kt"); + } + + @Test + @TestMetadata("lambdaReturningObject.kt") + public void testLambdaReturningObject() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/lambdaReturningObject.kt"); + } + + @Test + @TestMetadata("lambdas.kt") + public void testLambdas() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/lambdas.kt"); + } + + @Test + @TestMetadata("localClassesWithImplicit.kt") + public void testLocalClassesWithImplicit() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/localClassesWithImplicit.kt"); + } + + @Test + @TestMetadata("loops.kt") + public void testLoops() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/loops.kt"); + } + + @Test + @TestMetadata("postponedLambdaInConstructor.kt") + public void testPostponedLambdaInConstructor() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdaInConstructor.kt"); + } + + @Test + @TestMetadata("postponedLambdaInReturn.kt") + public void testPostponedLambdaInReturn() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdaInReturn.kt"); + } + + @Test + @TestMetadata("postponedLambdas.kt") + public void testPostponedLambdas() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdas.kt"); + } + + @Test + @TestMetadata("propertiesAndInitBlocks.kt") + public void testPropertiesAndInitBlocks() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/propertiesAndInitBlocks.kt"); + } + + @Test + @TestMetadata("returnValuesFromLambda.kt") + public void testReturnValuesFromLambda() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/returnValuesFromLambda.kt"); + } + + @Test + @TestMetadata("safeCalls.kt") + public void testSafeCalls() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/safeCalls.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/simple.kt"); + } + + @Test + @TestMetadata("tryCatch.kt") + public void testTryCatch() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/tryCatch.kt"); + } + + @Test + @TestMetadata("variableInitializedInTryBlock.kt") + public void testVariableInitializedInTryBlock() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/variableInitializedInTryBlock.kt"); + } + + @Test + @TestMetadata("when.kt") + public void testWhen() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/cfg/when.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/checkers") + @TestDataPath("$PROJECT_ROOT") + public class Checkers { + @Test + public void testAllFilesPresentInCheckers() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/checkers"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("complexConflictingProjections.kt") + public void testComplexConflictingProjections() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/checkers/complexConflictingProjections.kt"); + } + + @Test + @TestMetadata("importAnnotationWithRequiresOptIn.kt") + public void testImportAnnotationWithRequiresOptIn() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/checkers/importAnnotationWithRequiresOptIn.kt"); + } + + @Test + @TestMetadata("internalImplicitInvokeFromInlineFun.kt") + public void testInternalImplicitInvokeFromInlineFun() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/checkers/internalImplicitInvokeFromInlineFun.kt"); + } + + @Test + @TestMetadata("internalSuperCallFromInlineFun.kt") + public void testInternalSuperCallFromInlineFun() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/checkers/internalSuperCallFromInlineFun.kt"); + } + + @Test + @TestMetadata("invalidLhsOfClassLiteral.kt") + public void testInvalidLhsOfClassLiteral() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/checkers/invalidLhsOfClassLiteral.kt"); + } + + @Test + @TestMetadata("notUselessCast_1.kt") + public void testNotUselessCast_1() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/checkers/notUselessCast_1.kt"); + } + + @Test + @TestMetadata("notUselessCast_2.kt") + public void testNotUselessCast_2() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/checkers/notUselessCast_2.kt"); + } + + @Test + @TestMetadata("notUselessCast_3.kt") + public void testNotUselessCast_3() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/checkers/notUselessCast_3.kt"); + } + + @Test + @TestMetadata("recursiveDependencyBetweenReturnTypeAndSupertype.kt") + public void testRecursiveDependencyBetweenReturnTypeAndSupertype() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/checkers/recursiveDependencyBetweenReturnTypeAndSupertype.kt"); + } + + @Test + @TestMetadata("redundantNullCheckOnAsCast.kt") + public void testRedundantNullCheckOnAsCast() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/checkers/redundantNullCheckOnAsCast.kt"); + } + + @Test + @TestMetadata("unsuccessfullCastToStartProjectedType.kt") + public void testUnsuccessfullCastToStartProjectedType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/checkers/unsuccessfullCastToStartProjectedType.kt"); + } + + @Test + @TestMetadata("uselessCastLeadsToRecursiveProblem.kt") + public void testUselessCastLeadsToRecursiveProblem() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/checkers/uselessCastLeadsToRecursiveProblem.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/constVal") + @TestDataPath("$PROJECT_ROOT") + public class ConstVal { + @Test + public void testAllFilesPresentInConstVal() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/constVal"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("const.kt") + public void testConst() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/constVal/const.kt"); + } + + @Test + @TestMetadata("constValNotTopLevelOrObject.kt") + public void testConstValNotTopLevelOrObject() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/constVal/constValNotTopLevelOrObject.kt"); + } + + @Test + @TestMetadata("constValWithGetterOrDelegate.kt") + public void testConstValWithGetterOrDelegate() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/constVal/constValWithGetterOrDelegate.kt"); + } + + @Test + @TestMetadata("constValWithTypealiasType.kt") + public void testConstValWithTypealiasType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/constVal/constValWithTypealiasType.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/constructors") + @TestDataPath("$PROJECT_ROOT") + public class Constructors { + @Test + public void testAllFilesPresentInConstructors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/constructors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("erroneousDelegatedConstructorCall.kt") + public void testErroneousDelegatedConstructorCall() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/constructors/erroneousDelegatedConstructorCall.kt"); + } + + @Test + @TestMetadata("noSuperCallInSupertypes.kt") + public void testNoSuperCallInSupertypes() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/constructors/noSuperCallInSupertypes.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/contracts") + @TestDataPath("$PROJECT_ROOT") + public class Contracts { + @Test + public void testAllFilesPresentInContracts() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/contracts"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("contractFromOtherModule.kt") + public void testContractFromOtherModule() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/contracts/contractFromOtherModule.kt"); + } + + @Test + @TestMetadata("contractFromOtherModule_samePackage.kt") + public void testContractFromOtherModule_samePackage() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/contracts/contractFromOtherModule_samePackage.kt"); + } + + @Test + @TestMetadata("contractOnInfixFunction.kt") + public void testContractOnInfixFunction() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/contracts/contractOnInfixFunction.kt"); + } + + @Test + @TestMetadata("disabledFeature.kt") + public void testDisabledFeature() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/contracts/disabledFeature.kt"); + } + + @Test + @TestMetadata("genericContract.kt") + public void testGenericContract() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/contracts/genericContract.kt"); + } + + @Test + @TestMetadata("inPlaceAfterVararg.kt") + public void testInPlaceAfterVararg() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/contracts/inPlaceAfterVararg.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/delegates") + @TestDataPath("$PROJECT_ROOT") + public class Delegates { + @Test + public void testAllFilesPresentInDelegates() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/delegates"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("callOnThisInDelegateExpression.kt") + public void testCallOnThisInDelegateExpression() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/delegates/callOnThisInDelegateExpression.kt"); + } + + @Test + @TestMetadata("delegateInference.kt") + public void testDelegateInference() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/delegates/delegateInference.kt"); + } + + @Test + @TestMetadata("delegateWithArgInference.kt") + public void testDelegateWithArgInference() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/delegates/delegateWithArgInference.kt"); + } + + @Test + @TestMetadata("delegateWithLambda.kt") + public void testDelegateWithLambda() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/delegates/delegateWithLambda.kt"); + } + + @Test + @TestMetadata("extensionGenericGetValue.kt") + public void testExtensionGenericGetValue() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/delegates/extensionGenericGetValue.kt"); + } + + @Test + @TestMetadata("extensionGetValueWithTypeVariableAsReceiver.kt") + public void testExtensionGetValueWithTypeVariableAsReceiver() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/delegates/extensionGetValueWithTypeVariableAsReceiver.kt"); + } + + @Test + @TestMetadata("kt41982.kt") + public void testKt41982() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/delegates/kt41982.kt"); + } + + @Test + @TestMetadata("provideDelegate.kt") + public void testProvideDelegate() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/delegates/provideDelegate.kt"); + } + + @Test + @TestMetadata("receiverInference.kt") + public void testReceiverInference() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/delegates/receiverInference.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/diagnostics") + @TestDataPath("$PROJECT_ROOT") + public class Diagnostics { + @Test + @TestMetadata("abstractSuperCall.kt") + public void testAbstractSuperCall() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/abstractSuperCall.kt"); + } + + @Test + @TestMetadata("abstractSuperCallInPresenseOfNonAbstractMethodInParent.kt") + public void testAbstractSuperCallInPresenseOfNonAbstractMethodInParent() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/abstractSuperCallInPresenseOfNonAbstractMethodInParent.kt"); + } + + @Test + public void testAllFilesPresentInDiagnostics() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/diagnostics"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("annotationArgumentKClassLiteralTypeError.kt") + public void testAnnotationArgumentKClassLiteralTypeError() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentKClassLiteralTypeError.kt"); + } + + @Test + @TestMetadata("annotationArgumentMustBeConst.kt") + public void testAnnotationArgumentMustBeConst() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeConst.kt"); + } + + @Test + @TestMetadata("annotationArgumentMustBeEnumConst.kt") + public void testAnnotationArgumentMustBeEnumConst() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeEnumConst.kt"); + } + + @Test + @TestMetadata("annotationArgumentMustBeKClassLiteral.kt") + public void testAnnotationArgumentMustBeKClassLiteral() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeKClassLiteral.kt"); + } + + @Test + @TestMetadata("annotationClassMember.kt") + public void testAnnotationClassMember() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationClassMember.kt"); + } + + @Test + @TestMetadata("anonymousObjectByDelegate.kt") + public void testAnonymousObjectByDelegate() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/anonymousObjectByDelegate.kt"); + } + + @Test + @TestMetadata("classInSupertypeForEnum.kt") + public void testClassInSupertypeForEnum() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/classInSupertypeForEnum.kt"); + } + + @Test + @TestMetadata("conflictingOverloads.kt") + public void testConflictingOverloads() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/conflictingOverloads.kt"); + } + + @Test + @TestMetadata("conflictingProjection.kt") + public void testConflictingProjection() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/conflictingProjection.kt"); + } + + @Test + @TestMetadata("constructorInInterface.kt") + public void testConstructorInInterface() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/constructorInInterface.kt"); + } + + @Test + @TestMetadata("cyclicConstructorDelegationCall.kt") + public void testCyclicConstructorDelegationCall() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/cyclicConstructorDelegationCall.kt"); + } + + @Test + @TestMetadata("delegationInInterface.kt") + public void testDelegationInInterface() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/delegationInInterface.kt"); + } + + @Test + @TestMetadata("delegationSuperCallInEnumConstructor.kt") + public void testDelegationSuperCallInEnumConstructor() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/delegationSuperCallInEnumConstructor.kt"); + } + + @Test + @TestMetadata("explicitDelegationCallRequired.kt") + public void testExplicitDelegationCallRequired() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/explicitDelegationCallRequired.kt"); + } + + @Test + @TestMetadata("inapplicableLateinitModifier.kt") + public void testInapplicableLateinitModifier() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/inapplicableLateinitModifier.kt"); + } + + @Test + @TestMetadata("incompatibleModifiers.kt") + public void testIncompatibleModifiers() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/incompatibleModifiers.kt"); + } + + @Test + @TestMetadata("infixFunctions.kt") + public void testInfixFunctions() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/infixFunctions.kt"); + } + + @Test + @TestMetadata("instanceAccessBeforeSuperCall.kt") + public void testInstanceAccessBeforeSuperCall() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/instanceAccessBeforeSuperCall.kt"); + } + + @Test + @TestMetadata("interfaceWithSuperclass.kt") + public void testInterfaceWithSuperclass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/interfaceWithSuperclass.kt"); + } + + @Test + @TestMetadata("localAnnotationClass.kt") + public void testLocalAnnotationClass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/localAnnotationClass.kt"); + } + + @Test + @TestMetadata("localEntitytNotAllowed.kt") + public void testLocalEntitytNotAllowed() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/localEntitytNotAllowed.kt"); + } + + @Test + @TestMetadata("manyCompanionObjects.kt") + public void testManyCompanionObjects() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/manyCompanionObjects.kt"); + } + + @Test + @TestMetadata("methodOfAnyImplementedInInterface.kt") + public void testMethodOfAnyImplementedInInterface() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/methodOfAnyImplementedInInterface.kt"); + } + + @Test + @TestMetadata("multipleBounds.kt") + public void testMultipleBounds() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/multipleBounds.kt"); + } + + @Test + @TestMetadata("nonConstValInAnnotationArgument.kt") + public void testNonConstValInAnnotationArgument() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/nonConstValInAnnotationArgument.kt"); + } + + @Test + @TestMetadata("notASupertype.kt") + public void testNotASupertype() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/notASupertype.kt"); + } + + @Test + @TestMetadata("primaryConstructorParametersInSecondaryConstructor.kt") + public void testPrimaryConstructorParametersInSecondaryConstructor() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/primaryConstructorParametersInSecondaryConstructor.kt"); + } + + @Test + @TestMetadata("primaryConstructorRequiredForDataClass.kt") + public void testPrimaryConstructorRequiredForDataClass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/primaryConstructorRequiredForDataClass.kt"); + } + + @Test + @TestMetadata("projectionsOnNonClassTypeArguments.kt") + public void testProjectionsOnNonClassTypeArguments() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/projectionsOnNonClassTypeArguments.kt"); + } + + @Test + @TestMetadata("propertyTypeMismatchOnOverride.kt") + public void testPropertyTypeMismatchOnOverride() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/propertyTypeMismatchOnOverride.kt"); + } + + @Test + @TestMetadata("qualifiedSupertypeExtendedByOtherSupertype.kt") + public void testQualifiedSupertypeExtendedByOtherSupertype() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/qualifiedSupertypeExtendedByOtherSupertype.kt"); + } + + @Test + @TestMetadata("redundantModifier.kt") + public void testRedundantModifier() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/redundantModifier.kt"); + } + + @Test + @TestMetadata("repeatedModifier.kt") + public void testRepeatedModifier() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/repeatedModifier.kt"); + } + + @Test + @TestMetadata("returnTypeMismatchOnOverride.kt") + public void testReturnTypeMismatchOnOverride() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/returnTypeMismatchOnOverride.kt"); + } + + @Test + @TestMetadata("sealedClassConstructorCall.kt") + public void testSealedClassConstructorCall() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedClassConstructorCall.kt"); + } + + @Test + @TestMetadata("sealedSupertype.kt") + public void testSealedSupertype() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedSupertype.kt"); + } + + @Test + @TestMetadata("someOverridesTest.kt") + public void testSomeOverridesTest() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/someOverridesTest.kt"); + } + + @Test + @TestMetadata("superCallWithDelegation.kt") + public void testSuperCallWithDelegation() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/superCallWithDelegation.kt"); + } + + @Test + @TestMetadata("superIsNotAnExpression.kt") + public void testSuperIsNotAnExpression() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/superIsNotAnExpression.kt"); + } + + @Test + @TestMetadata("superNotAvailable.kt") + public void testSuperNotAvailable() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/superNotAvailable.kt"); + } + + @Test + @TestMetadata("superclassNotAccessibleFromInterface.kt") + public void testSuperclassNotAccessibleFromInterface() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/superclassNotAccessibleFromInterface.kt"); + } + + @Test + @TestMetadata("supertypeInitializedInInterface.kt") + public void testSupertypeInitializedInInterface() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/supertypeInitializedInInterface.kt"); + } + + @Test + @TestMetadata("supertypeInitializedWithoutPrimaryConstructor.kt") + public void testSupertypeInitializedWithoutPrimaryConstructor() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/supertypeInitializedWithoutPrimaryConstructor.kt"); + } + + @Test + @TestMetadata("testIllegalAnnotationClass.kt") + public void testTestIllegalAnnotationClass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/testIllegalAnnotationClass.kt"); + } + + @Test + @TestMetadata("typeArgumentsNotAllowed.kt") + public void testTypeArgumentsNotAllowed() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/typeArgumentsNotAllowed.kt"); + } + + @Test + @TestMetadata("typeOfAnnotationMember.kt") + public void testTypeOfAnnotationMember() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/typeOfAnnotationMember.kt"); + } + + @Test + @TestMetadata("typeParametersInEnum.kt") + public void testTypeParametersInEnum() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/typeParametersInEnum.kt"); + } + + @Test + @TestMetadata("typeParametersInObject.kt") + public void testTypeParametersInObject() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/typeParametersInObject.kt"); + } + + @Test + @TestMetadata("upperBoundViolated.kt") + public void testUpperBoundViolated() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/upperBoundViolated.kt"); + } + + @Test + @TestMetadata("valOnAnnotationParameter.kt") + public void testValOnAnnotationParameter() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/valOnAnnotationParameter.kt"); + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/diagnostics/functionAsExpression") + @TestDataPath("$PROJECT_ROOT") + public class FunctionAsExpression { + @Test + public void testAllFilesPresentInFunctionAsExpression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/diagnostics/functionAsExpression"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("Parameters.kt") + public void testParameters() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/functionAsExpression/Parameters.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/exhaustiveness") + @TestDataPath("$PROJECT_ROOT") + public class Exhaustiveness { + @Test + public void testAllFilesPresentInExhaustiveness() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/exhaustiveness"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/exhaustiveness/negative") + @TestDataPath("$PROJECT_ROOT") + public class Negative { + @Test + public void testAllFilesPresentInNegative() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/exhaustiveness/negative"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("missingBooleanBranch.kt") + public void testMissingBooleanBranch() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness/negative/missingBooleanBranch.kt"); + } + + @Test + @TestMetadata("missingElse.kt") + public void testMissingElse() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness/negative/missingElse.kt"); + } + + @Test + @TestMetadata("missingEnumEntry.kt") + public void testMissingEnumEntry() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness/negative/missingEnumEntry.kt"); + } + + @Test + @TestMetadata("missingSealedInheritor.kt") + public void testMissingSealedInheritor() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness/negative/missingSealedInheritor.kt"); + } + + @Test + @TestMetadata("nonExhaustiveWhenWithoutCoercionToUnit.kt") + public void testNonExhaustiveWhenWithoutCoercionToUnit() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness/negative/nonExhaustiveWhenWithoutCoercionToUnit.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive") + @TestDataPath("$PROJECT_ROOT") + public class Positive { + @Test + public void testAllFilesPresentInPositive() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("annotatedBranch.kt") + public void testAnnotatedBranch() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/annotatedBranch.kt"); + } + + @Test + @TestMetadata("exhaustiveWhenAndDNNType.kt") + public void testExhaustiveWhenAndDNNType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/exhaustiveWhenAndDNNType.kt"); + } + + @Test + @TestMetadata("exhaustiveWhenAndFlexibleType.kt") + public void testExhaustiveWhenAndFlexibleType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/exhaustiveWhenAndFlexibleType.kt"); + } + + @Test + @TestMetadata("exhaustiveness_boolean.kt") + public void testExhaustiveness_boolean() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/exhaustiveness_boolean.kt"); + } + + @Test + @TestMetadata("exhaustiveness_enum.kt") + public void testExhaustiveness_enum() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/exhaustiveness_enum.kt"); + } + + @Test + @TestMetadata("exhaustiveness_enumJava.kt") + public void testExhaustiveness_enumJava() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/exhaustiveness_enumJava.kt"); + } + + @Test + @TestMetadata("exhaustiveness_sealedClass.kt") + public void testExhaustiveness_sealedClass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/exhaustiveness_sealedClass.kt"); + } + + @Test + @TestMetadata("exhaustiveness_sealedObject.kt") + public void testExhaustiveness_sealedObject() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/exhaustiveness_sealedObject.kt"); + } + + @Test + @TestMetadata("exhaustiveness_sealedSubClass.kt") + public void testExhaustiveness_sealedSubClass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/exhaustiveness_sealedSubClass.kt"); + } + + @Test + @TestMetadata("exhaustiveness_smartcastedBoolean.kt") + public void testExhaustiveness_smartcastedBoolean() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/exhaustiveness_smartcastedBoolean.kt"); + } + + @Test + @TestMetadata("nestedIfInLambda.kt") + public void testNestedIfInLambda() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/nestedIfInLambda.kt"); + } + + @Test + @TestMetadata("nonExhaustiveWhenWithCoercionToUnit.kt") + public void testNonExhaustiveWhenWithCoercionToUnit() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/nonExhaustiveWhenWithCoercionToUnit.kt"); + } + + @Test + @TestMetadata("sameBranchMultipleConditions.kt") + public void testSameBranchMultipleConditions() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/sameBranchMultipleConditions.kt"); + } + + @Test + @TestMetadata("smartcastToExhaustiveInterface.kt") + public void testSmartcastToExhaustiveInterface() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/smartcastToExhaustiveInterface.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/expresssions") + @TestDataPath("$PROJECT_ROOT") + public class Expresssions { + @Test + @TestMetadata("access.kt") + public void testAccess() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/access.kt"); + } + + @Test + public void testAllFilesPresentInExpresssions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("annotationWithReturn.kt") + public void testAnnotationWithReturn() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/annotationWithReturn.kt"); + } + + @Test + @TestMetadata("annotations.kt") + public void testAnnotations() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/annotations.kt"); + } + + @Test + @TestMetadata("baseQualifier.kt") + public void testBaseQualifier() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/baseQualifier.kt"); + } + + @Test + @TestMetadata("blockLocalScopes.kt") + public void testBlockLocalScopes() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/blockLocalScopes.kt"); + } + + @Test + @TestMetadata("CallBasedInExpressionGenerator.kt") + public void testCallBasedInExpressionGenerator() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/CallBasedInExpressionGenerator.kt"); + } + + @Test + @TestMetadata("checkArguments.kt") + public void testCheckArguments() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/checkArguments.kt"); + } + + @Test + @TestMetadata("classifierAccessFromCompanion.kt") + public void testClassifierAccessFromCompanion() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/classifierAccessFromCompanion.kt"); + } + + @Test + @TestMetadata("companion.kt") + public void testCompanion() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/companion.kt"); + } + + @Test + @TestMetadata("companionExtension.kt") + public void testCompanionExtension() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/companionExtension.kt"); + } + + @Test + @TestMetadata("constructor.kt") + public void testConstructor() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/constructor.kt"); + } + + @Test + @TestMetadata("dispatchReceiver.kt") + public void testDispatchReceiver() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/dispatchReceiver.kt"); + } + + @Test + @TestMetadata("enumEntryUse.kt") + public void testEnumEntryUse() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/enumEntryUse.kt"); + } + + @Test + @TestMetadata("enumValues.kt") + public void testEnumValues() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/enumValues.kt"); + } + + @Test + @TestMetadata("errCallable.kt") + public void testErrCallable() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/errCallable.kt"); + } + + @Test + @TestMetadata("extensionPropertyInLambda.kt") + public void testExtensionPropertyInLambda() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/extensionPropertyInLambda.kt"); + } + + @Test + @TestMetadata("genericDecorator.kt") + public void testGenericDecorator() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/genericDecorator.kt"); + } + + @Test + @TestMetadata("genericDescriptor.kt") + public void testGenericDescriptor() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/genericDescriptor.kt"); + } + + @Test + @TestMetadata("genericDiagnostic.kt") + public void testGenericDiagnostic() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/genericDiagnostic.kt"); + } + + @Test + @TestMetadata("genericPropertyAccess.kt") + public void testGenericPropertyAccess() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/genericPropertyAccess.kt"); + } + + @Test + @TestMetadata("genericUsedInFunction.kt") + public void testGenericUsedInFunction() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/genericUsedInFunction.kt"); + } + + @Test + @TestMetadata("importedReceiver.kt") + public void testImportedReceiver() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/importedReceiver.kt"); + } + + @Test + @TestMetadata("innerQualifier.kt") + public void testInnerQualifier() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/innerQualifier.kt"); + } + + @Test + @TestMetadata("innerWithSuperCompanion.kt") + public void testInnerWithSuperCompanion() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/innerWithSuperCompanion.kt"); + } + + @Test + @TestMetadata("javaFieldCallable.kt") + public void testJavaFieldCallable() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/javaFieldCallable.kt"); + } + + @Test + @TestMetadata("lambda.kt") + public void testLambda() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/lambda.kt"); + } + + @Test + @TestMetadata("lambdaWithReceiver.kt") + public void testLambdaWithReceiver() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/lambdaWithReceiver.kt"); + } + + @Test + @TestMetadata("localClassAccessesContainingClass.kt") + public void testLocalClassAccessesContainingClass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/localClassAccessesContainingClass.kt"); + } + + @Test + @TestMetadata("localConstructor.kt") + public void testLocalConstructor() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/localConstructor.kt"); + } + + @Test + @TestMetadata("localExtension.kt") + public void testLocalExtension() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/localExtension.kt"); + } + + @Test + @TestMetadata("localImplicitBodies.kt") + public void testLocalImplicitBodies() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/localImplicitBodies.kt"); + } + + @Test + @TestMetadata("localInnerClass.kt") + public void testLocalInnerClass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/localInnerClass.kt"); + } + + @Test + @TestMetadata("localObjects.kt") + public void testLocalObjects() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/localObjects.kt"); + } + + @Test + @TestMetadata("localScopes.kt") + public void testLocalScopes() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/localScopes.kt"); + } + + @Test + @TestMetadata("localTypes.kt") + public void testLocalTypes() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/localTypes.kt"); + } + + @Test + @TestMetadata("localWithBooleanNot.kt") + public void testLocalWithBooleanNot() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/localWithBooleanNot.kt"); + } + + @Test + @TestMetadata("memberExtension.kt") + public void testMemberExtension() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/memberExtension.kt"); + } + + @Test + @TestMetadata("nestedConstructorCallable.kt") + public void testNestedConstructorCallable() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/nestedConstructorCallable.kt"); + } + + @Test + @TestMetadata("nestedObjects.kt") + public void testNestedObjects() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/nestedObjects.kt"); + } + + @Test + @TestMetadata("nestedVisibility.kt") + public void testNestedVisibility() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/nestedVisibility.kt"); + } + + @Test + @TestMetadata("objectOverrideCallViaImport.kt") + public void testObjectOverrideCallViaImport() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/objectOverrideCallViaImport.kt"); + } + + @Test + @TestMetadata("objectVsProperty.kt") + public void testObjectVsProperty() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/objectVsProperty.kt"); + } + + @Test + @TestMetadata("objects.kt") + public void testObjects() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/objects.kt"); + } + + @Test + @TestMetadata("outerMemberAccesses.kt") + public void testOuterMemberAccesses() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/outerMemberAccesses.kt"); + } + + @Test + @TestMetadata("outerObject.kt") + public void testOuterObject() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/outerObject.kt"); + } + + @Test + @TestMetadata("overriddenJavaGetter.kt") + public void testOverriddenJavaGetter() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/overriddenJavaGetter.kt"); + } + + @Test + @TestMetadata("plusWithAssignSmartCast.kt") + public void testPlusWithAssignSmartCast() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/plusWithAssignSmartCast.kt"); + } + + @Test + @TestMetadata("privateObjectLiteral.kt") + public void testPrivateObjectLiteral() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/privateObjectLiteral.kt"); + } + + @Test + @TestMetadata("privateVisibility.kt") + public void testPrivateVisibility() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/privateVisibility.kt"); + } + + @Test + @TestMetadata("propertyAccessWithExplicitTypeArguments.kt") + public void testPropertyAccessWithExplicitTypeArguments() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/propertyAccessWithExplicitTypeArguments.kt"); + } + + @Test + @TestMetadata("protectedVisibility.kt") + public void testProtectedVisibility() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/protectedVisibility.kt"); + } + + @Test + @TestMetadata("qualifiedExpressions.kt") + public void testQualifiedExpressions() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/qualifiedExpressions.kt"); + } + + @Test + @TestMetadata("qualifierPriority.kt") + public void testQualifierPriority() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/qualifierPriority.kt"); + } + + @Test + @TestMetadata("receiverConsistency.kt") + public void testReceiverConsistency() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/receiverConsistency.kt"); + } + + @Test + @TestMetadata("sameReceiver.kt") + public void testSameReceiver() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/sameReceiver.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/simple.kt"); + } + + @Test + @TestMetadata("syntheticInImplicitBody.kt") + public void testSyntheticInImplicitBody() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/syntheticInImplicitBody.kt"); + } + + @Test + @TestMetadata("syntheticSmartCast.kt") + public void testSyntheticSmartCast() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/syntheticSmartCast.kt"); + } + + @Test + @TestMetadata("this.kt") + public void testThis() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/this.kt"); + } + + @Test + @TestMetadata("topExtensionVsOuterMember.kt") + public void testTopExtensionVsOuterMember() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/topExtensionVsOuterMember.kt"); + } + + @Test + @TestMetadata("typeAliasConstructor.kt") + public void testTypeAliasConstructor() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/typeAliasConstructor.kt"); + } + + @Test + @TestMetadata("vararg.kt") + public void testVararg() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/vararg.kt"); + } + + @Test + @TestMetadata("when.kt") + public void testWhen() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/when.kt"); + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/expresssions/inference") + @TestDataPath("$PROJECT_ROOT") + public class Inference { + @Test + public void testAllFilesPresentInInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions/inference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("id.kt") + public void testId() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/inference/id.kt"); + } + + @Test + @TestMetadata("typeParameters.kt") + public void testTypeParameters() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters.kt"); + } + + @Test + @TestMetadata("typeParameters2.kt") + public void testTypeParameters2() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters2.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke") + @TestDataPath("$PROJECT_ROOT") + public class Invoke { + @Test + public void testAllFilesPresentInInvoke() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("doubleBrackets.kt") + public void testDoubleBrackets() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/doubleBrackets.kt"); + } + + @Test + @TestMetadata("explicitReceiver.kt") + public void testExplicitReceiver() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/explicitReceiver.kt"); + } + + @Test + @TestMetadata("explicitReceiver2.kt") + public void testExplicitReceiver2() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/explicitReceiver2.kt"); + } + + @Test + @TestMetadata("extension.kt") + public void testExtension() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/extension.kt"); + } + + @Test + @TestMetadata("extensionOnObject.kt") + public void testExtensionOnObject() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/extensionOnObject.kt"); + } + + @Test + @TestMetadata("extensionSafeCall.kt") + public void testExtensionSafeCall() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/extensionSafeCall.kt"); + } + + @Test + @TestMetadata("farInvokeExtension.kt") + public void testFarInvokeExtension() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/farInvokeExtension.kt"); + } + + @Test + @TestMetadata("implicitTypeOrder.kt") + public void testImplicitTypeOrder() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/implicitTypeOrder.kt"); + } + + @Test + @TestMetadata("inBrackets.kt") + public void testInBrackets() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/inBrackets.kt"); + } + + @Test + @TestMetadata("incorrectInvokeReceiver.kt") + public void testIncorrectInvokeReceiver() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/incorrectInvokeReceiver.kt"); + } + + @Test + @TestMetadata("propertyFromParameter.kt") + public void testPropertyFromParameter() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/propertyFromParameter.kt"); + } + + @Test + @TestMetadata("propertyWithExtensionType.kt") + public void testPropertyWithExtensionType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/propertyWithExtensionType.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/simple.kt"); + } + + @Test + @TestMetadata("threeReceivers.kt") + public void testThreeReceivers() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/threeReceivers.kt"); + } + + @Test + @TestMetadata("threeReceiversCorrect.kt") + public void testThreeReceiversCorrect() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/threeReceiversCorrect.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/expresssions/operators") + @TestDataPath("$PROJECT_ROOT") + public class Operators { + @Test + public void testAllFilesPresentInOperators() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions/operators"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("plus.kt") + public void testPlus() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plus.kt"); + } + + @Test + @TestMetadata("plusAndPlusAssign.kt") + public void testPlusAndPlusAssign() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plusAndPlusAssign.kt"); + } + + @Test + @TestMetadata("plusAssign.kt") + public void testPlusAssign() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plusAssign.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/extendedCheckers") + @TestDataPath("$PROJECT_ROOT") + public class ExtendedCheckers { + @Test + public void testAllFilesPresentInExtendedCheckers() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/extendedCheckers"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("ArrayEqualityCanBeReplacedWithEquals.kt") + public void testArrayEqualityCanBeReplacedWithEquals() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/ArrayEqualityCanBeReplacedWithEquals.kt"); + } + + @Test + @TestMetadata("CanBeValChecker.kt") + public void testCanBeValChecker() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/CanBeValChecker.kt"); + } + + @Test + @TestMetadata("RedundantExplicitTypeChecker.kt") + public void testRedundantExplicitTypeChecker() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantExplicitTypeChecker.kt"); + } + + @Test + @TestMetadata("RedundantModalityModifierChecker.kt") + public void testRedundantModalityModifierChecker() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantModalityModifierChecker.kt"); + } + + @Test + @TestMetadata("RedundantReturnUnitTypeChecker.kt") + public void testRedundantReturnUnitTypeChecker() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantReturnUnitTypeChecker.kt"); + } + + @Test + @TestMetadata("RedundantSetterParameterTypeChecker.kt") + public void testRedundantSetterParameterTypeChecker() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantSetterParameterTypeChecker.kt"); + } + + @Test + @TestMetadata("RedundantSingleExpressionStringTemplateChecker.kt") + public void testRedundantSingleExpressionStringTemplateChecker() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantSingleExpressionStringTemplateChecker.kt"); + } + + @Test + @TestMetadata("RedundantVisibilityDueToOverride.kt") + public void testRedundantVisibilityDueToOverride() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantVisibilityDueToOverride.kt"); + } + + @Test + @TestMetadata("RedundantVisibilityModifierChecker.kt") + public void testRedundantVisibilityModifierChecker() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantVisibilityModifierChecker.kt"); + } + + @Test + @TestMetadata("RedundantVisibilityModifierCheckerForInnerComponents.kt") + public void testRedundantVisibilityModifierCheckerForInnerComponents() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantVisibilityModifierCheckerForInnerComponents.kt"); + } + + @Test + @TestMetadata("RedundantVisibilityModifierCheckerWithExplicitApiMode.kt") + public void testRedundantVisibilityModifierCheckerWithExplicitApiMode() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantVisibilityModifierCheckerWithExplicitApiMode.kt"); + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment") + @TestDataPath("$PROJECT_ROOT") + public class CanBeReplacedWithOperatorAssignment { + @Test + public void testAllFilesPresentInCanBeReplacedWithOperatorAssignment() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("BasicTest.kt") + public void testBasicTest() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/BasicTest.kt"); + } + + @Test + @TestMetadata("ComplexExpression.kt") + public void testComplexExpression() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/ComplexExpression.kt"); + } + + @Test + @TestMetadata("flexibleTypeBug.kt") + public void testFlexibleTypeBug() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/flexibleTypeBug.kt"); + } + + @Test + @TestMetadata("illegalMultipleOperators.kt") + public void testIllegalMultipleOperators() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/illegalMultipleOperators.kt"); + } + + @Test + @TestMetadata("illegalMultipleOperatorsMiddle.kt") + public void testIllegalMultipleOperatorsMiddle() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/illegalMultipleOperatorsMiddle.kt"); + } + + @Test + @TestMetadata("invalidSubtraction.kt") + public void testInvalidSubtraction() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/invalidSubtraction.kt"); + } + + @Test + @TestMetadata("list.kt") + public void testList() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/list.kt"); + } + + @Test + @TestMetadata("logicOperators.kt") + public void testLogicOperators() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/logicOperators.kt"); + } + + @Test + @TestMetadata("multipleOperators.kt") + public void testMultipleOperators() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/multipleOperators.kt"); + } + + @Test + @TestMetadata("multipleOperatorsRightSideRepeat.kt") + public void testMultipleOperatorsRightSideRepeat() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/multipleOperatorsRightSideRepeat.kt"); + } + + @Test + @TestMetadata("mutableList.kt") + public void testMutableList() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/mutableList.kt"); + } + + @Test + @TestMetadata("nonCommutativeRepeat.kt") + public void testNonCommutativeRepeat() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/nonCommutativeRepeat.kt"); + } + + @Test + @TestMetadata("nonRepeatingAssignment.kt") + public void testNonRepeatingAssignment() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/nonRepeatingAssignment.kt"); + } + + @Test + @TestMetadata("OperatorAssignment.kt") + public void testOperatorAssignment() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/OperatorAssignment.kt"); + } + + @Test + @TestMetadata("plusAssignConflict.kt") + public void testPlusAssignConflict() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/plusAssignConflict.kt"); + } + + @Test + @TestMetadata("rightSideRepeat.kt") + public void testRightSideRepeat() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/rightSideRepeat.kt"); + } + + @Test + @TestMetadata("simpleAssign.kt") + public void testSimpleAssign() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/simpleAssign.kt"); + } + + @Test + @TestMetadata("validAddition.kt") + public void testValidAddition() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/validAddition.kt"); + } + + @Test + @TestMetadata("validSubtraction.kt") + public void testValidSubtraction() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/canBeReplacedWithOperatorAssignment/validSubtraction.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/emptyRangeChecker") + @TestDataPath("$PROJECT_ROOT") + public class EmptyRangeChecker { + @Test + public void testAllFilesPresentInEmptyRangeChecker() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/emptyRangeChecker"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("NoWarning.kt") + public void testNoWarning() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/emptyRangeChecker/NoWarning.kt"); + } + + @Test + @TestMetadata("Warning.kt") + public void testWarning() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/emptyRangeChecker/Warning.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod") + @TestDataPath("$PROJECT_ROOT") + public class RedundantCallOfConversionMethod { + @Test + public void testAllFilesPresentInRedundantCallOfConversionMethod() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("booleanToInt.kt") + public void testBooleanToInt() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/booleanToInt.kt"); + } + + @Test + @TestMetadata("byte.kt") + public void testByte() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/byte.kt"); + } + + @Test + @TestMetadata("char.kt") + public void testChar() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/char.kt"); + } + + @Test + @TestMetadata("double.kt") + public void testDouble() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/double.kt"); + } + + @Test + @TestMetadata("float.kt") + public void testFloat() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/float.kt"); + } + + @Test + @TestMetadata("int.kt") + public void testInt() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/int.kt"); + } + + @Test + @TestMetadata("long.kt") + public void testLong() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/long.kt"); + } + + @Test + @TestMetadata("nullable.kt") + public void testNullable() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/nullable.kt"); + } + + @Test + @TestMetadata("nullable2.kt") + public void testNullable2() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/nullable2.kt"); + } + + @Test + @TestMetadata("safeString.kt") + public void testSafeString() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/safeString.kt"); + } + + @Test + @TestMetadata("safeString2.kt") + public void testSafeString2() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/safeString2.kt"); + } + + @Test + @TestMetadata("short.kt") + public void testShort() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/short.kt"); + } + + @Test + @TestMetadata("string.kt") + public void testString() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/string.kt"); + } + + @Test + @TestMetadata("StringTemplate.kt") + public void testStringTemplate() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/StringTemplate.kt"); + } + + @Test + @TestMetadata("toOtherType.kt") + public void testToOtherType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/toOtherType.kt"); + } + + @Test + @TestMetadata("uByte.kt") + public void testUByte() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/uByte.kt"); + } + + @Test + @TestMetadata("uInt.kt") + public void testUInt() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/uInt.kt"); + } + + @Test + @TestMetadata("uLong.kt") + public void testULong() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/uLong.kt"); + } + + @Test + @TestMetadata("uShort.kt") + public void testUShort() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/uShort.kt"); + } + + @Test + @TestMetadata("variable.kt") + public void testVariable() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/RedundantCallOfConversionMethod/variable.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/unused") + @TestDataPath("$PROJECT_ROOT") + public class Unused { + @Test + public void testAllFilesPresentInUnused() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/unused"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("classProperty.kt") + public void testClassProperty() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/unused/classProperty.kt"); + } + + @Test + @TestMetadata("invoke.kt") + public void testInvoke() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/unused/invoke.kt"); + } + + @Test + @TestMetadata("lambda.kt") + public void testLambda() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/unused/lambda.kt"); + } + + @Test + @TestMetadata("localVariable.kt") + public void testLocalVariable() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/unused/localVariable.kt"); + } + + @Test + @TestMetadata("localVariableInSecondaryConstructor.kt") + public void testLocalVariableInSecondaryConstructor() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/unused/localVariableInSecondaryConstructor.kt"); + } + + @Test + @TestMetadata("manyLocalVariables.kt") + public void testManyLocalVariables() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/unused/manyLocalVariables.kt"); + } + + @Test + @TestMetadata("usedInAnnotationArguments.kt") + public void testUsedInAnnotationArguments() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/unused/usedInAnnotationArguments.kt"); + } + + @Test + @TestMetadata("valueIsNeverRead.kt") + public void testValueIsNeverRead() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/unused/valueIsNeverRead.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/UselessCallOnNotNullChecker") + @TestDataPath("$PROJECT_ROOT") + public class UselessCallOnNotNullChecker { + @Test + public void testAllFilesPresentInUselessCallOnNotNullChecker() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/UselessCallOnNotNullChecker"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("Basic.kt") + public void testBasic() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/UselessCallOnNotNullChecker/Basic.kt"); + } + + @Test + @TestMetadata("NotNullType.kt") + public void testNotNullType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/UselessCallOnNotNullChecker/NotNullType.kt"); + } + + @Test + @TestMetadata("NotNullTypeChain.kt") + public void testNotNullTypeChain() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/UselessCallOnNotNullChecker/NotNullTypeChain.kt"); + } + + @Test + @TestMetadata("NullOrBlankSafe.kt") + public void testNullOrBlankSafe() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/UselessCallOnNotNullChecker/NullOrBlankSafe.kt"); + } + + @Test + @TestMetadata("NullOrEmpty.kt") + public void testNullOrEmpty() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/UselessCallOnNotNullChecker/NullOrEmpty.kt"); + } + + @Test + @TestMetadata("NullOrEmptyFake.kt") + public void testNullOrEmptyFake() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/UselessCallOnNotNullChecker/NullOrEmptyFake.kt"); + } + + @Test + @TestMetadata("NullOrEmptySafe.kt") + public void testNullOrEmptySafe() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/UselessCallOnNotNullChecker/NullOrEmptySafe.kt"); + } + + @Test + @TestMetadata("OrEmptyFake.kt") + public void testOrEmptyFake() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/UselessCallOnNotNullChecker/OrEmptyFake.kt"); + } + + @Test + @TestMetadata("SafeCall.kt") + public void testSafeCall() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/UselessCallOnNotNullChecker/SafeCall.kt"); + } + + @Test + @TestMetadata("Sequence.kt") + public void testSequence() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/UselessCallOnNotNullChecker/Sequence.kt"); + } + + @Test + @TestMetadata("String.kt") + public void testString() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/extendedCheckers/UselessCallOnNotNullChecker/String.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/fromBuilder") + @TestDataPath("$PROJECT_ROOT") + public class FromBuilder { + @Test + public void testAllFilesPresentInFromBuilder() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/fromBuilder"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("complexTypes.kt") + public void testComplexTypes() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/fromBuilder/complexTypes.kt"); + } + + @Test + @TestMetadata("enums.kt") + public void testEnums() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/fromBuilder/enums.kt"); + } + + @Test + @TestMetadata("noPrimaryConstructor.kt") + public void testNoPrimaryConstructor() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/fromBuilder/noPrimaryConstructor.kt"); + } + + @Test + @TestMetadata("simpleClass.kt") + public void testSimpleClass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/fromBuilder/simpleClass.kt"); + } + + @Test + @TestMetadata("typeParameters.kt") + public void testTypeParameters() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/fromBuilder/typeParameters.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/inference") + @TestDataPath("$PROJECT_ROOT") + public class Inference { + @Test + public void testAllFilesPresentInInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/inference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("callableReferenceOnInstance.kt") + public void testCallableReferenceOnInstance() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/callableReferenceOnInstance.kt"); + } + + @Test + @TestMetadata("callableReferenceToLocalClass.kt") + public void testCallableReferenceToLocalClass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/callableReferenceToLocalClass.kt"); + } + + @Test + @TestMetadata("callableReferencesAndDefaultParameters.kt") + public void testCallableReferencesAndDefaultParameters() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/callableReferencesAndDefaultParameters.kt"); + } + + @Test + @TestMetadata("capturedTypeForJavaTypeParameter.kt") + public void testCapturedTypeForJavaTypeParameter() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/capturedTypeForJavaTypeParameter.kt"); + } + + @Test + @TestMetadata("coercionToUnitWithEarlyReturn.kt") + public void testCoercionToUnitWithEarlyReturn() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/coercionToUnitWithEarlyReturn.kt"); + } + + @Test + @TestMetadata("definitelyNotNullIntersectionType.kt") + public void testDefinitelyNotNullIntersectionType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/definitelyNotNullIntersectionType.kt"); + } + + @Test + @TestMetadata("dnnThrowJavaCall.kt") + public void testDnnThrowJavaCall() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/dnnThrowJavaCall.kt"); + } + + @Test + @TestMetadata("elvisAndUnit.kt") + public void testElvisAndUnit() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/elvisAndUnit.kt"); + } + + @Test + @TestMetadata("equals.kt") + public void testEquals() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/equals.kt"); + } + + @Test + @TestMetadata("extensionCallableReferences.kt") + public void testExtensionCallableReferences() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/extensionCallableReferences.kt"); + } + + @Test + @TestMetadata("integerLiteralAsComparable.kt") + public void testIntegerLiteralAsComparable() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/integerLiteralAsComparable.kt"); + } + + @Test + @TestMetadata("intersectionTypesInConstraints.kt") + public void testIntersectionTypesInConstraints() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/intersectionTypesInConstraints.kt"); + } + + @Test + @TestMetadata("javaCollector.kt") + public void testJavaCollector() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/javaCollector.kt"); + } + + @Test + @TestMetadata("kt40131.kt") + public void testKt40131() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/kt40131.kt"); + } + + @Test + @TestMetadata("kt41989.kt") + public void testKt41989() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/kt41989.kt"); + } + + @Test + @TestMetadata("kt53494.kt") + public void testKt53494() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/kt53494.kt"); + } + + @Test + @TestMetadata("kt54990.kt") + public void testKt54990() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/kt54990.kt"); + } + + @Test + @TestMetadata("lambdaAsReturnStatementOfLambda.kt") + public void testLambdaAsReturnStatementOfLambda() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/lambdaAsReturnStatementOfLambda.kt"); + } + + @Test + @TestMetadata("lambdaInElvis.kt") + public void testLambdaInElvis() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/lambdaInElvis.kt"); + } + + @Test + @TestMetadata("lambdaWithoutExpectedType.kt") + public void testLambdaWithoutExpectedType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/lambdaWithoutExpectedType.kt"); + } + + @Test + @TestMetadata("lambdasReturns.kt") + public void testLambdasReturns() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/lambdasReturns.kt"); + } + + @Test + @TestMetadata("nestedExtensionFunctionType.kt") + public void testNestedExtensionFunctionType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/nestedExtensionFunctionType.kt"); + } + + @Test + @TestMetadata("nestedLambdas.kt") + public void testNestedLambdas() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/nestedLambdas.kt"); + } + + @Test + @TestMetadata("nullableIntegerLiteralType.kt") + public void testNullableIntegerLiteralType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/nullableIntegerLiteralType.kt"); + } + + @Test + @TestMetadata("overloadResolutionByLambdaArgumentType.kt") + public void testOverloadResolutionByLambdaArgumentType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/overloadResolutionByLambdaArgumentType.kt"); + } + + @Test + @TestMetadata("receiverWithCapturedType.kt") + public void testReceiverWithCapturedType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/receiverWithCapturedType.kt"); + } + + @Test + @TestMetadata("recursiveSelfTypes.kt") + public void testRecursiveSelfTypes() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/recursiveSelfTypes.kt"); + } + + @Test + @TestMetadata("selfTypeFromJava.kt") + public void testSelfTypeFromJava() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/selfTypeFromJava.kt"); + } + + @Test + @TestMetadata("simpleCapturedTypes.kt") + public void testSimpleCapturedTypes() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/simpleCapturedTypes.kt"); + } + + @Test + @TestMetadata("typeDepthForTypeAlias.kt") + public void testTypeDepthForTypeAlias() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/typeDepthForTypeAlias.kt"); + } + + @Test + @TestMetadata("unitUpperBound.kt") + public void testUnitUpperBound() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/unitUpperBound.kt"); + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/inference/builderInference") + @TestDataPath("$PROJECT_ROOT") + public class BuilderInference { + @Test + public void testAllFilesPresentInBuilderInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/inference/builderInference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("ifInBuildMap.kt") + public void testIfInBuildMap() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inference/builderInference/ifInBuildMap.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/inlineClasses") + @TestDataPath("$PROJECT_ROOT") + public class InlineClasses { + @Test + public void testAllFilesPresentInInlineClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/inlineClasses"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("inlineClassConstructor.kt") + public void testInlineClassConstructor() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inlineClasses/inlineClassConstructor.kt"); + } + + @Test + @TestMetadata("inlineClassDeclaration.kt") + public void testInlineClassDeclaration() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inlineClasses/inlineClassDeclaration.kt"); + } + + @Test + @TestMetadata("inlineClassMembers.kt") + public void testInlineClassMembers() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/inlineClasses/inlineClassMembers.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/innerClasses") + @TestDataPath("$PROJECT_ROOT") + public class InnerClasses { + @Test + public void testAllFilesPresentInInnerClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/innerClasses"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("inner.kt") + public void testInner() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/innerClasses/inner.kt"); + } + + @Test + @TestMetadata("innerTypeFromSuperClassInBody.kt") + public void testInnerTypeFromSuperClassInBody() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/innerClasses/innerTypeFromSuperClassInBody.kt"); + } + + @Test + @TestMetadata("innerTypes.kt") + public void testInnerTypes() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/innerClasses/innerTypes.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/innerClasses/simple.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/localClasses") + @TestDataPath("$PROJECT_ROOT") + public class LocalClasses { + @Test + public void testAllFilesPresentInLocalClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/localClasses"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("anonObject.kt") + public void testAnonObject() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/localClasses/anonObject.kt"); + } + + @Test + @TestMetadata("anonymousInAnonymous.kt") + public void testAnonymousInAnonymous() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/localClasses/anonymousInAnonymous.kt"); + } + + @Test + @TestMetadata("implicitInAnonymous.kt") + public void testImplicitInAnonymous() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/localClasses/implicitInAnonymous.kt"); + } + + @Test + @TestMetadata("implicitInLocalClasses.kt") + public void testImplicitInLocalClasses() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/localClasses/implicitInLocalClasses.kt"); + } + + @Test + @TestMetadata("overrideInLocal.kt") + public void testOverrideInLocal() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/localClasses/overrideInLocal.kt"); + } + + @Test + @TestMetadata("typesFromSuperClasses.kt") + public void testTypesFromSuperClasses() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/localClasses/typesFromSuperClasses.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/multifile") + @TestDataPath("$PROJECT_ROOT") + public class Multifile { + @Test + public void testAllFilesPresentInMultifile() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/multifile"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("Annotations.kt") + public void testAnnotations() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/multifile/Annotations.kt"); + } + + @Test + @TestMetadata("ByteArray.kt") + public void testByteArray() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/multifile/ByteArray.kt"); + } + + @Test + @TestMetadata("importFromObject.kt") + public void testImportFromObject() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/multifile/importFromObject.kt"); + } + + @Test + @TestMetadata("NestedSuperType.kt") + public void testNestedSuperType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/multifile/NestedSuperType.kt"); + } + + @Test + @TestMetadata("sealedStarImport.kt") + public void testSealedStarImport() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/multifile/sealedStarImport.kt"); + } + + @Test + @TestMetadata("simpleAliasedImport.kt") + public void testSimpleAliasedImport() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/multifile/simpleAliasedImport.kt"); + } + + @Test + @TestMetadata("simpleImport.kt") + public void testSimpleImport() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/multifile/simpleImport.kt"); + } + + @Test + @TestMetadata("simpleImportNested.kt") + public void testSimpleImportNested() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/multifile/simpleImportNested.kt"); + } + + @Test + @TestMetadata("simpleImportOuter.kt") + public void testSimpleImportOuter() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/multifile/simpleImportOuter.kt"); + } + + @Test + @TestMetadata("simpleStarImport.kt") + public void testSimpleStarImport() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/multifile/simpleStarImport.kt"); + } + + @Test + @TestMetadata("TypeAliasExpansion.kt") + public void testTypeAliasExpansion() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/multifile/TypeAliasExpansion.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/overrides") + @TestDataPath("$PROJECT_ROOT") + public class Overrides { + @Test + public void testAllFilesPresentInOverrides() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/overrides"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("generics.kt") + public void testGenerics() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/overrides/generics.kt"); + } + + @Test + @TestMetadata("protobufExt.kt") + public void testProtobufExt() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/overrides/protobufExt.kt"); + } + + @Test + @TestMetadata("sameValueParametersDifferentReceiver.kt") + public void testSameValueParametersDifferentReceiver() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/overrides/sameValueParametersDifferentReceiver.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/overrides/simple.kt"); + } + + @Test + @TestMetadata("simpleFakeOverride.kt") + public void testSimpleFakeOverride() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/overrides/simpleFakeOverride.kt"); + } + + @Test + @TestMetadata("simpleMostSpecific.kt") + public void testSimpleMostSpecific() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/overrides/simpleMostSpecific.kt"); + } + + @Test + @TestMetadata("supertypeGenerics.kt") + public void testSupertypeGenerics() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/overrides/supertypeGenerics.kt"); + } + + @Test + @TestMetadata("supertypeGenericsComplex.kt") + public void testSupertypeGenericsComplex() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/overrides/supertypeGenericsComplex.kt"); + } + + @Test + @TestMetadata("three.kt") + public void testThree() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/overrides/three.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/problems") + @TestDataPath("$PROJECT_ROOT") + public class Problems { + @Test + public void testAllFilesPresentInProblems() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/problems"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("classLiteralWithExclExcl.kt") + public void testClassLiteralWithExclExcl() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/classLiteralWithExclExcl.kt"); + } + + @Test + @TestMetadata("compilerPhase.kt") + public void testCompilerPhase() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/compilerPhase.kt"); + } + + @Test + @TestMetadata("complexLambdaWithTypeVariableAsExpectedType.kt") + public void testComplexLambdaWithTypeVariableAsExpectedType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/complexLambdaWithTypeVariableAsExpectedType.kt"); + } + + @Test + @TestMetadata("defaultParametersFromDifferentScopes.kt") + public void testDefaultParametersFromDifferentScopes() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/defaultParametersFromDifferentScopes.kt"); + } + + @Test + @TestMetadata("definitelyNotNullAndOriginalType.kt") + public void testDefinitelyNotNullAndOriginalType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/definitelyNotNullAndOriginalType.kt"); + } + + @Test + @TestMetadata("doubleGenericDiamond.kt") + public void testDoubleGenericDiamond() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/doubleGenericDiamond.kt"); + } + + @Test + @TestMetadata("emptySelectorInQualifiedExpression.kt") + public void testEmptySelectorInQualifiedExpression() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/emptySelectorInQualifiedExpression.kt"); + } + + @Test + @TestMetadata("enumEntryFieldShadow.kt") + public void testEnumEntryFieldShadow() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/enumEntryFieldShadow.kt"); + } + + @Test + @TestMetadata("expectConstructor.kt") + public void testExpectConstructor() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/expectConstructor.kt"); + } + + @Test + @TestMetadata("fakeTypeMismatchOnExtensionReference.kt") + public void testFakeTypeMismatchOnExtensionReference() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/fakeTypeMismatchOnExtensionReference.kt"); + } + + @Test + @TestMetadata("falseIntersection.kt") + public void testFalseIntersection() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/falseIntersection.kt"); + } + + @Test + @TestMetadata("flexibleTypeVarAgainstNull.kt") + public void testFlexibleTypeVarAgainstNull() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/flexibleTypeVarAgainstNull.kt"); + } + + @Test + @TestMetadata("inaccessibleJavaGetter.kt") + public void testInaccessibleJavaGetter() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/inaccessibleJavaGetter.kt"); + } + + @Test + @TestMetadata("innerClassHierarchy.kt") + public void testInnerClassHierarchy() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/innerClassHierarchy.kt"); + } + + @Test + @TestMetadata("invalidCode.kt") + public void testInvalidCode() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/invalidCode.kt"); + } + + @Test + @TestMetadata("javaClassWithEmptyAnnotationName.kt") + public void testJavaClassWithEmptyAnnotationName() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/javaClassWithEmptyAnnotationName.kt"); + } + + @Test + @TestMetadata("javaQualifier.kt") + public void testJavaQualifier() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/javaQualifier.kt"); + } + + @Test + @TestMetadata("kt42346.kt") + public void testKt42346() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/kt42346.kt"); + } + + @Test + @TestMetadata("multipleJavaClassesInOneFile.kt") + public void testMultipleJavaClassesInOneFile() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/multipleJavaClassesInOneFile.kt"); + } + + @Test + @TestMetadata("objectDerivedFromInnerClass.kt") + public void testObjectDerivedFromInnerClass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/objectDerivedFromInnerClass.kt"); + } + + @Test + @TestMetadata("questionableSmartCast.kt") + public void testQuestionableSmartCast() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/questionableSmartCast.kt"); + } + + @Test + @TestMetadata("recursiveNamedAnnotation.kt") + public void testRecursiveNamedAnnotation() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/recursiveNamedAnnotation.kt"); + } + + @Test + @TestMetadata("safeCallInvoke.kt") + public void testSafeCallInvoke() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/safeCallInvoke.kt"); + } + + @Test + @TestMetadata("secondaryConstructorCfg.kt") + public void testSecondaryConstructorCfg() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/secondaryConstructorCfg.kt"); + } + + @Test + @TestMetadata("symbolsAndDescriptors.kt") + public void testSymbolsAndDescriptors() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/symbolsAndDescriptors.kt"); + } + + @Test + @TestMetadata("transform.kt") + public void testTransform() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/transform.kt"); + } + + @Test + @TestMetadata("typeArgumentsOnThis.kt") + public void testTypeArgumentsOnThis() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/problems/typeArgumentsOnThis.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/properties") + @TestDataPath("$PROJECT_ROOT") + public class Properties { + @Test + public void testAllFilesPresentInProperties() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/properties"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("assignToStarProjectedType.kt") + public void testAssignToStarProjectedType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/properties/assignToStarProjectedType.kt"); + } + + @Test + @TestMetadata("getterWithEarlyReturn.kt") + public void testGetterWithEarlyReturn() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/properties/getterWithEarlyReturn.kt"); + } + + @Test + @TestMetadata("javaAccessorConversion.kt") + public void testJavaAccessorConversion() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/properties/javaAccessorConversion.kt"); + } + + @Test + @TestMetadata("javaAccessorsComplex.kt") + public void testJavaAccessorsComplex() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/properties/javaAccessorsComplex.kt"); + } + + @Test + @TestMetadata("kotlinOverridesJavaComplex.kt") + public void testKotlinOverridesJavaComplex() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/properties/kotlinOverridesJavaComplex.kt"); + } + + @Test + @TestMetadata("lazyValWithElvisToNothingInside.kt") + public void testLazyValWithElvisToNothingInside() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/properties/lazyValWithElvisToNothingInside.kt"); + } + + @Test + @TestMetadata("noBackingFieldForExtension.kt") + public void testNoBackingFieldForExtension() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/properties/noBackingFieldForExtension.kt"); + } + + @Test + @TestMetadata("noBackingFieldInProperty.kt") + public void testNoBackingFieldInProperty() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/properties/noBackingFieldInProperty.kt"); + } + + @Test + @TestMetadata("syntheticPropertiesForJavaAnnotations.kt") + public void testSyntheticPropertiesForJavaAnnotations() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/properties/syntheticPropertiesForJavaAnnotations.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/propertyVsField") + @TestDataPath("$PROJECT_ROOT") + public class PropertyVsField { + @Test + public void testAllFilesPresentInPropertyVsField() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/propertyVsField"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("fieldPropertyShadow.kt") + public void testFieldPropertyShadow() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/propertyVsField/fieldPropertyShadow.kt"); + } + + @Test + @TestMetadata("javaFieldAndKotlinPropertyReferenceFromInner.kt") + public void testJavaFieldAndKotlinPropertyReferenceFromInner() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/propertyVsField/javaFieldAndKotlinPropertyReferenceFromInner.kt"); + } + + @Test + @TestMetadata("propertyAndTwoFields.kt") + public void testPropertyAndTwoFields() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/propertyVsField/propertyAndTwoFields.kt"); + } + + @Test + @TestMetadata("propertyFieldShadow.kt") + public void testPropertyFieldShadow() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/propertyVsField/propertyFieldShadow.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/references") + @TestDataPath("$PROJECT_ROOT") + public class References { + @Test + public void testAllFilesPresentInReferences() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/references"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("ambigousParenthesizedReference.kt") + public void testAmbigousParenthesizedReference() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/references/ambigousParenthesizedReference.kt"); + } + + @Test + @TestMetadata("incorrectReferenceOnInnerClassMember.kt") + public void testIncorrectReferenceOnInnerClassMember() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/references/incorrectReferenceOnInnerClassMember.kt"); + } + + @Test + @TestMetadata("integerLiteralInLhs.kt") + public void testIntegerLiteralInLhs() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/references/integerLiteralInLhs.kt"); + } + + @Test + @TestMetadata("leakedImplicitType.kt") + public void testLeakedImplicitType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/references/leakedImplicitType.kt"); + } + + @Test + @TestMetadata("referenceToExtension.kt") + public void testReferenceToExtension() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/references/referenceToExtension.kt"); + } + + @Test + @TestMetadata("referenceToField.kt") + public void testReferenceToField() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/references/referenceToField.kt"); + } + + @Test + @TestMetadata("referenceToSyntheticJavaPropertyWithProjection.kt") + public void testReferenceToSyntheticJavaPropertyWithProjection() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/references/referenceToSyntheticJavaPropertyWithProjection.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/references/simple.kt"); + } + + @Test + @TestMetadata("superMember.kt") + public void testSuperMember() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/references/superMember.kt"); + } + + @Test + @TestMetadata("unresovledReferenceInFinally.kt") + public void testUnresovledReferenceInFinally() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/references/unresovledReferenceInFinally.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/samConstructors") + @TestDataPath("$PROJECT_ROOT") + public class SamConstructors { + @Test + public void testAllFilesPresentInSamConstructors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/samConstructors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("funInterfaceConstructorReference.kt") + public void testFunInterfaceConstructorReference() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/samConstructors/funInterfaceConstructorReference.kt"); + } + + @Test + @TestMetadata("genericSam.kt") + public void testGenericSam() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSam.kt"); + } + + @Test + @TestMetadata("genericSamInferenceFromExpectType.kt") + public void testGenericSamInferenceFromExpectType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSamInferenceFromExpectType.kt"); + } + + @Test + @TestMetadata("kotlinSam.kt") + public void testKotlinSam() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/samConstructors/kotlinSam.kt"); + } + + @Test + @TestMetadata("realConstructorFunction.kt") + public void testRealConstructorFunction() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/samConstructors/realConstructorFunction.kt"); + } + + @Test + @TestMetadata("runnable.kt") + public void testRunnable() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/samConstructors/runnable.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/samConstructors/simple.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/samConversions") + @TestDataPath("$PROJECT_ROOT") + public class SamConversions { + @Test + public void testAllFilesPresentInSamConversions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/samConversions"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("genericSam.kt") + public void testGenericSam() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/samConversions/genericSam.kt"); + } + + @Test + @TestMetadata("kotlinSam.kt") + public void testKotlinSam() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/samConversions/kotlinSam.kt"); + } + + @Test + @TestMetadata("notSamBecauseOfSupertype.kt") + public void testNotSamBecauseOfSupertype() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/samConversions/notSamBecauseOfSupertype.kt"); + } + + @Test + @TestMetadata("nothingVararg.kt") + public void testNothingVararg() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/samConversions/nothingVararg.kt"); + } + + @Test + @TestMetadata("runnable.kt") + public void testRunnable() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/samConversions/runnable.kt"); + } + + @Test + @TestMetadata("samConversionInConstructorCall.kt") + public void testSamConversionInConstructorCall() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/samConversions/samConversionInConstructorCall.kt"); + } + + @Test + @TestMetadata("samSupertype.kt") + public void testSamSupertype() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/samConversions/samSupertype.kt"); + } + + @Test + @TestMetadata("samSupertypeWithOverride.kt") + public void testSamSupertypeWithOverride() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/samConversions/samSupertypeWithOverride.kt"); + } + + @Test + @TestMetadata("samWithEquals.kt") + public void testSamWithEquals() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/samConversions/samWithEquals.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/samConversions/simple.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/scopes") + @TestDataPath("$PROJECT_ROOT") + public class Scopes { + @Test + public void testAllFilesPresentInScopes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/scopes"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("explicitOverrideOfTwoMembers.kt") + public void testExplicitOverrideOfTwoMembers() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/scopes/explicitOverrideOfTwoMembers.kt"); + } + + @Test + @TestMetadata("explicitOverrideOfTwoMembers_java.kt") + public void testExplicitOverrideOfTwoMembers_java() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/scopes/explicitOverrideOfTwoMembers_java.kt"); + } + + @Test + @TestMetadata("getterOverrideAndKotlinProperty.kt") + public void testGetterOverrideAndKotlinProperty() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/scopes/getterOverrideAndKotlinProperty.kt"); + } + + @Test + @TestMetadata("intersectionOverrideOfTwoMembers.kt") + public void testIntersectionOverrideOfTwoMembers() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/scopes/intersectionOverrideOfTwoMembers.kt"); + } + + @Test + @TestMetadata("intersectionOverrideOfTwoMembers_java.kt") + public void testIntersectionOverrideOfTwoMembers_java() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/scopes/intersectionOverrideOfTwoMembers_java.kt"); + } + + @Test + @TestMetadata("javaFunctionAndKotlinPropertyFromDifferentSupertypes.kt") + public void testJavaFunctionAndKotlinPropertyFromDifferentSupertypes() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/scopes/javaFunctionAndKotlinPropertyFromDifferentSupertypes.kt"); + } + + @Test + @TestMetadata("kotlinAccessorsLikeFunctionsThrowJavaClass.kt") + public void testKotlinAccessorsLikeFunctionsThrowJavaClass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/scopes/kotlinAccessorsLikeFunctionsThrowJavaClass.kt"); + } + + @Test + @TestMetadata("noIntersectionOverrideOfTwoMembers.kt") + public void testNoIntersectionOverrideOfTwoMembers() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/scopes/noIntersectionOverrideOfTwoMembers.kt"); + } + + @Test + @TestMetadata("noIntersectionOverrideOfTwoMembers_java.kt") + public void testNoIntersectionOverrideOfTwoMembers_java() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/scopes/noIntersectionOverrideOfTwoMembers_java.kt"); + } + + @Test + @TestMetadata("publicJavaAndPrivateKotlinVar.kt") + public void testPublicJavaAndPrivateKotlinVar() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/scopes/publicJavaAndPrivateKotlinVar.kt"); + } + + @Test + @TestMetadata("specialFunctionInJava_1.kt") + public void testSpecialFunctionInJava_1() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/scopes/specialFunctionInJava_1.kt"); + } + + @Test + @TestMetadata("specialFunctionInJava_2.kt") + public void testSpecialFunctionInJava_2() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/scopes/specialFunctionInJava_2.kt"); + } + + @Test + @TestMetadata("specialFunctionInJava_3.kt") + public void testSpecialFunctionInJava_3() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/scopes/specialFunctionInJava_3.kt"); + } + + @Test + @TestMetadata("specialFunctionInJava_4.kt") + public void testSpecialFunctionInJava_4() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/scopes/specialFunctionInJava_4.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/smartcasts") + @TestDataPath("$PROJECT_ROOT") + public class Smartcasts { + @Test + @TestMetadata("accessToMemberAfterReceiverReassignment.kt") + public void testAccessToMemberAfterReceiverReassignment() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/accessToMemberAfterReceiverReassignment.kt"); + } + + @Test + public void testAllFilesPresentInSmartcasts() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("bangbang.kt") + public void testBangbang() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/bangbang.kt"); + } + + @Test + @TestMetadata("casts.kt") + public void testCasts() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/casts.kt"); + } + + @Test + @TestMetadata("contractSafeCall.kt") + public void testContractSafeCall() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/contractSafeCall.kt"); + } + + @Test + @TestMetadata("equalsAndIdentity.kt") + public void testEqualsAndIdentity() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/equalsAndIdentity.kt"); + } + + @Test + @TestMetadata("incorrectSmartcastToNothing.kt") + public void testIncorrectSmartcastToNothing() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/incorrectSmartcastToNothing.kt"); + } + + @Test + @TestMetadata("kt10240.kt") + public void testKt10240() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/kt10240.kt"); + } + + @Test + @TestMetadata("kt37327.kt") + public void testKt37327() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/kt37327.kt"); + } + + @Test + @TestMetadata("kt39000.kt") + public void testKt39000() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/kt39000.kt"); + } + + @Test + @TestMetadata("kt50788.kt") + public void testKt50788() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/kt50788.kt"); + } + + @Test + @TestMetadata("kt50875.kt") + public void testKt50875() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/kt50875.kt"); + } + + @Test + @TestMetadata("literalInWhenSubject.kt") + public void testLiteralInWhenSubject() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/literalInWhenSubject.kt"); + } + + @Test + @TestMetadata("longElvisChain.kt") + public void testLongElvisChain() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/longElvisChain.kt"); + } + + @Test + @TestMetadata("multipleCasts.kt") + public void testMultipleCasts() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/multipleCasts.kt"); + } + + @Test + @TestMetadata("nullability.kt") + public void testNullability() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/nullability.kt"); + } + + @Test + @TestMetadata("orInWhenBranch.kt") + public void testOrInWhenBranch() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/orInWhenBranch.kt"); + } + + @Test + @TestMetadata("smartCastInInit.kt") + public void testSmartCastInInit() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/smartCastInInit.kt"); + } + + @Test + @TestMetadata("smartcastInByClause.kt") + public void testSmartcastInByClause() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/smartcastInByClause.kt"); + } + + @Test + @TestMetadata("smartcastOnFunctionalType.kt") + public void testSmartcastOnFunctionalType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/smartcastOnFunctionalType.kt"); + } + + @Test + @TestMetadata("smartcastOnImplicitReceiverOfCallableReference.kt") + public void testSmartcastOnImplicitReceiverOfCallableReference() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/smartcastOnImplicitReceiverOfCallableReference.kt"); + } + + @Test + @TestMetadata("smartcastToNothing.kt") + public void testSmartcastToNothing() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/smartcastToNothing.kt"); + } + + @Test + @TestMetadata("smartcastToStarProjectedType.kt") + public void testSmartcastToStarProjectedType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/smartcastToStarProjectedType.kt"); + } + + @Test + @TestMetadata("smartcastToTypeParameter.kt") + public void testSmartcastToTypeParameter() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/smartcastToTypeParameter.kt"); + } + + @Test + @TestMetadata("smartcastedField.kt") + public void testSmartcastedField() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/smartcastedField.kt"); + } + + @Test + @TestMetadata("smartcastsFromEquals_differentModule.kt") + public void testSmartcastsFromEquals_differentModule() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/smartcastsFromEquals_differentModule.kt"); + } + + @Test + @TestMetadata("smartcastsFromEquals_sameModule.kt") + public void testSmartcastsFromEquals_sameModule() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/smartcastsFromEquals_sameModule.kt"); + } + + @Test + @TestMetadata("typeOfLambdaWithSmartcast.kt") + public void testTypeOfLambdaWithSmartcast() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/typeOfLambdaWithSmartcast.kt"); + } + + @Test + @TestMetadata("unstableSmartcastAndAmbiguity.kt") + public void testUnstableSmartcastAndAmbiguity() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/unstableSmartcastAndAmbiguity.kt"); + } + + @Test + @TestMetadata("valCapturedInLambda.kt") + public void testValCapturedInLambda() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/valCapturedInLambda.kt"); + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans") + @TestDataPath("$PROJECT_ROOT") + public class Booleans { + @Test + public void testAllFilesPresentInBooleans() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("booleanElvisBoundSmartcast.kt") + public void testBooleanElvisBoundSmartcast() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/booleanElvisBoundSmartcast.kt"); + } + + @Test + @TestMetadata("booleanOperators.kt") + public void testBooleanOperators() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/booleanOperators.kt"); + } + + @Test + @TestMetadata("equalsToBoolean.kt") + public void testEqualsToBoolean() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/equalsToBoolean.kt"); + } + + @Test + @TestMetadata("jumpFromRhsOfOperator.kt") + public void testJumpFromRhsOfOperator() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/jumpFromRhsOfOperator.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts") + @TestDataPath("$PROJECT_ROOT") + public class BoundSmartcasts { + @Test + public void testAllFilesPresentInBoundSmartcasts() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("assignToBoundSmartcastedVariable.kt") + public void testAssignToBoundSmartcastedVariable() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/assignToBoundSmartcastedVariable.kt"); + } + + @Test + @TestMetadata("boundSmartcastWithProjection.kt") + public void testBoundSmartcastWithProjection() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcastWithProjection.kt"); + } + + @Test + @TestMetadata("boundSmartcasts.kt") + public void testBoundSmartcasts() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcasts.kt"); + } + + @Test + @TestMetadata("boundSmartcastsInBranches.kt") + public void testBoundSmartcastsInBranches() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcastsInBranches.kt"); + } + + @Test + @TestMetadata("functionCallBound.kt") + public void testFunctionCallBound() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/functionCallBound.kt"); + } + + @Test + @TestMetadata("thisAssignment.kt") + public void testThisAssignment() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/thisAssignment.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures") + @TestDataPath("$PROJECT_ROOT") + public class ControlStructures { + @Test + public void testAllFilesPresentInControlStructures() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("earlyReturnInNonExhaustiveWhen.kt") + public void testEarlyReturnInNonExhaustiveWhen() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/earlyReturnInNonExhaustiveWhen.kt"); + } + + @Test + @TestMetadata("elvis.kt") + public void testElvis() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/elvis.kt"); + } + + @Test + @TestMetadata("returnFromWhen.kt") + public void testReturnFromWhen() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/returnFromWhen.kt"); + } + + @Test + @TestMetadata("returns.kt") + public void testReturns() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/returns.kt"); + } + + @Test + @TestMetadata("simpleIf.kt") + public void testSimpleIf() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/simpleIf.kt"); + } + + @Test + @TestMetadata("smartcastFromArgument.kt") + public void testSmartcastFromArgument() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/smartcastFromArgument.kt"); + } + + @Test + @TestMetadata("when.kt") + public void testWhen() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/when.kt"); + } + + @Test + @TestMetadata("whenSubjectExpression.kt") + public void testWhenSubjectExpression() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/whenSubjectExpression.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas") + @TestDataPath("$PROJECT_ROOT") + public class Lambdas { + @Test + public void testAllFilesPresentInLambdas() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("inPlaceLambdas.kt") + public void testInPlaceLambdas() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/inPlaceLambdas.kt"); + } + + @Test + @TestMetadata("lambdaInWhenBranch.kt") + public void testLambdaInWhenBranch() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/lambdaInWhenBranch.kt"); + } + + @Test + @TestMetadata("smartcastOnLambda.kt") + public void testSmartcastOnLambda() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/smartcastOnLambda.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/smartcasts/loops") + @TestDataPath("$PROJECT_ROOT") + public class Loops { + @Test + public void testAllFilesPresentInLoops() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/loops"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("dataFlowInfoFromWhileCondition.kt") + public void testDataFlowInfoFromWhileCondition() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/dataFlowInfoFromWhileCondition.kt"); + } + + @Test + @TestMetadata("elvisAtTheEndOfLoop.kt") + public void testElvisAtTheEndOfLoop() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/elvisAtTheEndOfLoop.kt"); + } + + @Test + @TestMetadata("endlessLoops.kt") + public void testEndlessLoops() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/endlessLoops.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/smartcasts/problems") + @TestDataPath("$PROJECT_ROOT") + public class Problems { + @Test + public void testAllFilesPresentInProblems() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/problems"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("invoke.kt") + public void testInvoke() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/problems/invoke.kt"); + } + + @Test + @TestMetadata("noSmartcastToNullableNothing.kt") + public void testNoSmartcastToNullableNothing() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/problems/noSmartcastToNullableNothing.kt"); + } + + @Test + @TestMetadata("smartcastToStarProjectedSubclass.kt") + public void testSmartcastToStarProjectedSubclass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/problems/smartcastToStarProjectedSubclass.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers") + @TestDataPath("$PROJECT_ROOT") + public class Receivers { + @Test + public void testAllFilesPresentInReceivers() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("implicitReceiverAsWhenSubject.kt") + public void testImplicitReceiverAsWhenSubject() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/implicitReceiverAsWhenSubject.kt"); + } + + @Test + @TestMetadata("implicitReceivers.kt") + public void testImplicitReceivers() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/implicitReceivers.kt"); + } + + @Test + @TestMetadata("mixingImplicitAndExplicitReceivers.kt") + public void testMixingImplicitAndExplicitReceivers() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/mixingImplicitAndExplicitReceivers.kt"); + } + + @Test + @TestMetadata("thisOfExtensionProperty.kt") + public void testThisOfExtensionProperty() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/thisOfExtensionProperty.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls") + @TestDataPath("$PROJECT_ROOT") + public class SafeCalls { + @Test + public void testAllFilesPresentInSafeCalls() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("assignSafeCall.kt") + public void testAssignSafeCall() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/assignSafeCall.kt"); + } + + @Test + @TestMetadata("boundSafeCallAndIsCheck.kt") + public void testBoundSafeCallAndIsCheck() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/boundSafeCallAndIsCheck.kt"); + } + + @Test + @TestMetadata("complexIfWithOr.kt") + public void testComplexIfWithOr() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/complexIfWithOr.kt"); + } + + @Test + @TestMetadata("safeCallAndEqualityToBool.kt") + public void testSafeCallAndEqualityToBool() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCallAndEqualityToBool.kt"); + } + + @Test + @TestMetadata("safeCalls.kt") + public void testSafeCalls() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCalls.kt"); + } + + @Test + @TestMetadata("unstableSmartCastOnSafeCallArgument.kt") + public void testUnstableSmartCastOnSafeCallArgument() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/unstableSmartCastOnSafeCallArgument.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/smartcasts/stability") + @TestDataPath("$PROJECT_ROOT") + public class Stability { + @Test + public void testAllFilesPresentInStability() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/stability"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("overridenOpenVal.kt") + public void testOverridenOpenVal() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/stability/overridenOpenVal.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/smartcasts/variables") + @TestDataPath("$PROJECT_ROOT") + public class Variables { + @Test + public void testAllFilesPresentInVariables() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/variables"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("delayedAssignment.kt") + public void testDelayedAssignment() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/delayedAssignment.kt"); + } + + @Test + @TestMetadata("smartcastAfterReassignment.kt") + public void testSmartcastAfterReassignment() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/smartcastAfterReassignment.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/stdlib") + @TestDataPath("$PROJECT_ROOT") + public class Stdlib { + @Test + public void testAllFilesPresentInStdlib() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/stdlib"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/stdlib/j+k") + @TestDataPath("$PROJECT_ROOT") + public class J_k { + @Test + public void testAllFilesPresentInJ_k() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/stdlib/j+k"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("ArrayInGenericArguments.kt") + public void testArrayInGenericArguments() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/stdlib/j+k/ArrayInGenericArguments.kt"); + } + + @Test + @TestMetadata("flexibleWildcard.kt") + public void testFlexibleWildcard() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/stdlib/j+k/flexibleWildcard.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/suppress") + @TestDataPath("$PROJECT_ROOT") + public class Suppress { + @Test + public void testAllFilesPresentInSuppress() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/suppress"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("allWarnings.kt") + public void testAllWarnings() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/suppress/allWarnings.kt"); + } + + @Test + @TestMetadata("multipleWarnings.kt") + public void testMultipleWarnings() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/suppress/multipleWarnings.kt"); + } + + @Test + @TestMetadata("singleError.kt") + public void testSingleError() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/suppress/singleError.kt"); + } + + @Test + @TestMetadata("singleWarning.kt") + public void testSingleWarning() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/suppress/singleWarning.kt"); + } + + @Test + @TestMetadata("withSuppression.kt") + public void testWithSuppression() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/suppress/withSuppression.kt"); + } + + @Test + @TestMetadata("withSuppression2.kt") + public void testWithSuppression2() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/suppress/withSuppression2.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/typeParameters") + @TestDataPath("$PROJECT_ROOT") + public class TypeParameters { + @Test + public void testAllFilesPresentInTypeParameters() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/typeParameters"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("kt38288.kt") + public void testKt38288() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/typeParameters/kt38288.kt"); + } + + @Test + @TestMetadata("starProjectionForMultipleBounds.kt") + public void testStarProjectionForMultipleBounds() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/typeParameters/starProjectionForMultipleBounds.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/types") + @TestDataPath("$PROJECT_ROOT") + public class Types { + @Test + public void testAllFilesPresentInTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/types"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("bareWithDnnArg.kt") + public void testBareWithDnnArg() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/types/bareWithDnnArg.kt"); + } + + @Test + @TestMetadata("bareWithFlexibleArg.kt") + public void testBareWithFlexibleArg() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/types/bareWithFlexibleArg.kt"); + } + + @Test + @TestMetadata("bareWithSubjectTypeAlias.kt") + public void testBareWithSubjectTypeAlias() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/types/bareWithSubjectTypeAlias.kt"); + } + + @Test + @TestMetadata("capturedParametersOfInnerClasses.kt") + public void testCapturedParametersOfInnerClasses() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/types/capturedParametersOfInnerClasses.kt"); + } + + @Test + @TestMetadata("castToBareType.kt") + public void testCastToBareType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/types/castToBareType.kt"); + } + + @Test + @TestMetadata("typeAliasInArguments.kt") + public void testTypeAliasInArguments() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/types/typeAliasInArguments.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/unqualifiedEnum") + @TestDataPath("$PROJECT_ROOT") + public class UnqualifiedEnum { + @Test + public void testAllFilesPresentInUnqualifiedEnum() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/unqualifiedEnum"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("correctJava.kt") + public void testCorrectJava() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/unqualifiedEnum/correctJava.kt"); + } + + @Test + @TestMetadata("incorrectJava.kt") + public void testIncorrectJava() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/unqualifiedEnum/incorrectJava.kt"); + } + + @Test + @TestMetadata("nested.kt") + public void testNested() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/unqualifiedEnum/nested.kt"); + } + + @Test + @TestMetadata("notInsideBranches.kt") + public void testNotInsideBranches() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/unqualifiedEnum/notInsideBranches.kt"); + } + + @Test + @TestMetadata("priority.kt") + public void testPriority() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/unqualifiedEnum/priority.kt"); + } + + @Test + @TestMetadata("typeAlias.kt") + public void testTypeAlias() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/unqualifiedEnum/typeAlias.kt"); + } + + @Test + @TestMetadata("unqualifiedEnum.kt") + public void testUnqualifiedEnum() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/unqualifiedEnum/unqualifiedEnum.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/visibility") + @TestDataPath("$PROJECT_ROOT") + public class Visibility { + @Test + public void testAllFilesPresentInVisibility() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/visibility"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("exposedFunctionParameterType.kt") + public void testExposedFunctionParameterType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionParameterType.kt"); + } + + @Test + @TestMetadata("exposedFunctionReturnType.kt") + public void testExposedFunctionReturnType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionReturnType.kt"); + } + + @Test + @TestMetadata("exposedPropertyType.kt") + public void testExposedPropertyType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/visibility/exposedPropertyType.kt"); + } + + @Test + @TestMetadata("exposedSupertype.kt") + public void testExposedSupertype() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/visibility/exposedSupertype.kt"); + } + + @Test + @TestMetadata("exposedTypeAlias.kt") + public void testExposedTypeAlias() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/visibility/exposedTypeAlias.kt"); + } + + @Test + @TestMetadata("exposedTypeParameters.kt") + public void testExposedTypeParameters() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/visibility/exposedTypeParameters.kt"); + } + + @Test + @TestMetadata("intersectionOverrideWithImplicitTypes.kt") + public void testIntersectionOverrideWithImplicitTypes() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/visibility/intersectionOverrideWithImplicitTypes.kt"); + } + + @Test + @TestMetadata("kotlinJavaKotlinHierarchy.kt") + public void testKotlinJavaKotlinHierarchy() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/visibility/kotlinJavaKotlinHierarchy.kt"); + } + + @Test + @TestMetadata("privateAliasInSamePackage.kt") + public void testPrivateAliasInSamePackage() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/visibility/privateAliasInSamePackage.kt"); + } + + @Test + @TestMetadata("protectedAnnotationClassFromJava.kt") + public void testProtectedAnnotationClassFromJava() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/visibility/protectedAnnotationClassFromJava.kt"); + } + + @Test + @TestMetadata("protectedInCompanion.kt") + public void testProtectedInCompanion() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/visibility/protectedInCompanion.kt"); + } + + @Test + @TestMetadata("singletonConstructors.kt") + public void testSingletonConstructors() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/visibility/singletonConstructors.kt"); + } + + @Test + @TestMetadata("superAccessToJavaField.kt") + public void testSuperAccessToJavaField() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/visibility/superAccessToJavaField.kt"); + } + + @Test + @TestMetadata("visibilityWithOverrides.kt") + public void testVisibilityWithOverrides() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/visibility/visibilityWithOverrides.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolve/withAllowedKotlinPackage") + @TestDataPath("$PROJECT_ROOT") + public class WithAllowedKotlinPackage { + @Test + public void testAllFilesPresentInWithAllowedKotlinPackage() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/withAllowedKotlinPackage"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("extensionFunctionAddedToStdlib.kt") + public void testExtensionFunctionAddedToStdlib() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/withAllowedKotlinPackage/extensionFunctionAddedToStdlib.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib") + @TestDataPath("$PROJECT_ROOT") + public class ResolveWithStdlib { + @Test + @TestMetadata("addAllOnJavaCollection.kt") + public void testAddAllOnJavaCollection() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/addAllOnJavaCollection.kt"); + } + + @Test + public void testAllFilesPresentInResolveWithStdlib() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("annotationUseSites.kt") + public void testAnnotationUseSites() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/annotationUseSites.kt"); + } + + @Test + @TestMetadata("arrayFilterCapturedType.kt") + public void testArrayFilterCapturedType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/arrayFilterCapturedType.kt"); + } + + @Test + @TestMetadata("arrayFirstOrNull.kt") + public void testArrayFirstOrNull() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/arrayFirstOrNull.kt"); + } + + @Test + @TestMetadata("arrayInLocal.kt") + public void testArrayInLocal() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/arrayInLocal.kt"); + } + + @Test + @TestMetadata("assignmentWithWrongLhs.kt") + public void testAssignmentWithWrongLhs() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/assignmentWithWrongLhs.kt"); + } + + @Test + @TestMetadata("backingField.kt") + public void testBackingField() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/backingField.kt"); + } + + @Test + @TestMetadata("classLiteralForParameter.kt") + public void testClassLiteralForParameter() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/classLiteralForParameter.kt"); + } + + @Test + @TestMetadata("cloneArray.kt") + public void testCloneArray() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/cloneArray.kt"); + } + + @Test + @TestMetadata("companionLoad.kt") + public void testCompanionLoad() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/companionLoad.kt"); + } + + @Test + @TestMetadata("complexPostponedCfg.kt") + public void testComplexPostponedCfg() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/complexPostponedCfg.kt"); + } + + @Test + @TestMetadata("components.kt") + public void testComponents() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/components.kt"); + } + + @Test + @TestMetadata("concurrent.kt") + public void testConcurrent() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/concurrent.kt"); + } + + @Test + @TestMetadata("concurrentMapOfAliases.kt") + public void testConcurrentMapOfAliases() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/concurrentMapOfAliases.kt"); + } + + @Test + @TestMetadata("emptyArray.kt") + public void testEmptyArray() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/emptyArray.kt"); + } + + @Test + @TestMetadata("enumValuesDeserialized.kt") + public void testEnumValuesDeserialized() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/enumValuesDeserialized.kt"); + } + + @Test + @TestMetadata("errorsInUnreachable.kt") + public void testErrorsInUnreachable() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/errorsInUnreachable.kt"); + } + + @Test + @TestMetadata("exception.kt") + public void testException() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/exception.kt"); + } + + @Test + @TestMetadata("factoryFunctionOverloads.kt") + public void testFactoryFunctionOverloads() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/factoryFunctionOverloads.kt"); + } + + @Test + @TestMetadata("fillInStackTrace.kt") + public void testFillInStackTrace() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/fillInStackTrace.kt"); + } + + @Test + @TestMetadata("functionAndFunctionN.kt") + public void testFunctionAndFunctionN() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/functionAndFunctionN.kt"); + } + + @Test + @TestMetadata("functionX.kt") + public void testFunctionX() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/functionX.kt"); + } + + @Test + @TestMetadata("getOnKProperty.kt") + public void testGetOnKProperty() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/getOnKProperty.kt"); + } + + @Test + @TestMetadata("getOrPutAmbiguity.kt") + public void testGetOrPutAmbiguity() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/getOrPutAmbiguity.kt"); + } + + @Test + @TestMetadata("hashMapTypeAlias.kt") + public void testHashMapTypeAlias() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/hashMapTypeAlias.kt"); + } + + @Test + @TestMetadata("hashSet.kt") + public void testHashSet() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/hashSet.kt"); + } + + @Test + @TestMetadata("hashTableWithForEach.kt") + public void testHashTableWithForEach() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/hashTableWithForEach.kt"); + } + + @Test + @TestMetadata("helloWorld.kt") + public void testHelloWorld() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/helloWorld.kt"); + } + + @Test + @TestMetadata("implicitReceiverOrder.kt") + public void testImplicitReceiverOrder() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/implicitReceiverOrder.kt"); + } + + @Test + @TestMetadata("inapplicableRemoveAll.kt") + public void testInapplicableRemoveAll() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/inapplicableRemoveAll.kt"); + } + + @Test + @TestMetadata("intersectDynamicAndString.kt") + public void testIntersectDynamicAndString() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/intersectDynamicAndString.kt"); + } + + @Test + @TestMetadata("intersectRawAndMutable.kt") + public void testIntersectRawAndMutable() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/intersectRawAndMutable.kt"); + } + + @Test + @TestMetadata("javaEnumSynthetic.kt") + public void testJavaEnumSynthetic() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/javaEnumSynthetic.kt"); + } + + @Test + @TestMetadata("javaLangComparator.kt") + public void testJavaLangComparator() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/javaLangComparator.kt"); + } + + @Test + @TestMetadata("kotlinComparatorAlias.kt") + public void testKotlinComparatorAlias() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/kotlinComparatorAlias.kt"); + } + + @Test + @TestMetadata("kt54220.kt") + public void testKt54220() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/kt54220.kt"); + } + + @Test + @TestMetadata("listPlusAssign.kt") + public void testListPlusAssign() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/listPlusAssign.kt"); + } + + @Test + @TestMetadata("lowPriorityInResolution.kt") + public void testLowPriorityInResolution() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/lowPriorityInResolution.kt"); + } + + @Test + @TestMetadata("mapList.kt") + public void testMapList() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/mapList.kt"); + } + + @Test + @TestMetadata("multipleImplicitReceivers.kt") + public void testMultipleImplicitReceivers() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/multipleImplicitReceivers.kt"); + } + + @Test + @TestMetadata("noneWithForEach.kt") + public void testNoneWithForEach() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/noneWithForEach.kt"); + } + + @Test + @TestMetadata("nullableTypeParameter.kt") + public void testNullableTypeParameter() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/nullableTypeParameter.kt"); + } + + @Test + @TestMetadata("plusAssignNullable.kt") + public void testPlusAssignNullable() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/plusAssignNullable.kt"); + } + + @Test + @TestMetadata("problems.kt") + public void testProblems() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems.kt"); + } + + @Test + @TestMetadata("rangeTo.kt") + public void testRangeTo() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/rangeTo.kt"); + } + + @Test + @TestMetadata("recursiveBug.kt") + public void testRecursiveBug() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/recursiveBug.kt"); + } + + @Test + @TestMetadata("reflectionClass.kt") + public void testReflectionClass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/reflectionClass.kt"); + } + + @Test + @TestMetadata("removeIf.kt") + public void testRemoveIf() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/removeIf.kt"); + } + + @Test + @TestMetadata("removeOnAbstractMap.kt") + public void testRemoveOnAbstractMap() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/removeOnAbstractMap.kt"); + } + + @Test + @TestMetadata("repeatedAnnotations.kt") + public void testRepeatedAnnotations() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/repeatedAnnotations.kt"); + } + + @Test + @TestMetadata("runOnIntegerLiteral.kt") + public void testRunOnIntegerLiteral() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/runOnIntegerLiteral.kt"); + } + + @Test + @TestMetadata("samForComparator.kt") + public void testSamForComparator() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/samForComparator.kt"); + } + + @Test + @TestMetadata("simpleLazy.kt") + public void testSimpleLazy() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/simpleLazy.kt"); + } + + @Test + @TestMetadata("stringConstructors.kt") + public void testStringConstructors() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/stringConstructors.kt"); + } + + @Test + @TestMetadata("toSortedMapWithComparator.kt") + public void testToSortedMapWithComparator() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/toSortedMapWithComparator.kt"); + } + + @Test + @TestMetadata("topLevelResolve.kt") + public void testTopLevelResolve() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/topLevelResolve.kt"); + } + + @Test + @TestMetadata("typeAliasDeserialization.kt") + public void testTypeAliasDeserialization() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/typeAliasDeserialization.kt"); + } + + @Test + @TestMetadata("typeAliasWithForEach.kt") + public void testTypeAliasWithForEach() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/typeAliasWithForEach.kt"); + } + + @Test + @TestMetadata("typeParameterDerived.kt") + public void testTypeParameterDerived() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/typeParameterDerived.kt"); + } + + @Test + @TestMetadata("unaryOperators.kt") + public void testUnaryOperators() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/unaryOperators.kt"); + } + + @Test + @TestMetadata("whenAsLambdaReturnStatement.kt") + public void testWhenAsLambdaReturnStatement() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/whenAsLambdaReturnStatement.kt"); + } + + @Test + @TestMetadata("withInInitializer.kt") + public void testWithInInitializer() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/withInInitializer.kt"); + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences") + @TestDataPath("$PROJECT_ROOT") + public class CallableReferences { + @Test + public void testAllFilesPresentInCallableReferences() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("beyoundCalls.kt") + public void testBeyoundCalls() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/beyoundCalls.kt"); + } + + @Test + @TestMetadata("coercionToUnit.kt") + public void testCoercionToUnit() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/coercionToUnit.kt"); + } + + @Test + @TestMetadata("companions.kt") + public void testCompanions() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/companions.kt"); + } + + @Test + @TestMetadata("constructors.kt") + public void testConstructors() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/constructors.kt"); + } + + @Test + @TestMetadata("differentLevels.kt") + public void testDifferentLevels() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/differentLevels.kt"); + } + + @Test + @TestMetadata("extensionReceiverInference.kt") + public void testExtensionReceiverInference() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/extensionReceiverInference.kt"); + } + + @Test + @TestMetadata("genericInReceiver.kt") + public void testGenericInReceiver() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/genericInReceiver.kt"); + } + + @Test + @TestMetadata("ifWithCR.kt") + public void testIfWithCR() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/ifWithCR.kt"); + } + + @Test + @TestMetadata("implicitTypes.kt") + public void testImplicitTypes() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.kt"); + } + + @Test + @TestMetadata("inferenceFromCallableReferenceType.kt") + public void testInferenceFromCallableReferenceType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/inferenceFromCallableReferenceType.kt"); + } + + @Test + @TestMetadata("inferenceFromExpectedType.kt") + public void testInferenceFromExpectedType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/inferenceFromExpectedType.kt"); + } + + @Test + @TestMetadata("javaStatic.kt") + public void testJavaStatic() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/javaStatic.kt"); + } + + @Test + @TestMetadata("manyCandidatesInference.kt") + public void testManyCandidatesInference() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/manyCandidatesInference.kt"); + } + + @Test + @TestMetadata("manyInnerCandidates.kt") + public void testManyInnerCandidates() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/manyInnerCandidates.kt"); + } + + @Test + @TestMetadata("manyInnerManyOuterCandidates.kt") + public void testManyInnerManyOuterCandidates() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/manyInnerManyOuterCandidates.kt"); + } + + @Test + @TestMetadata("manyInnermanyOuterCandidatesAmbiguity.kt") + public void testManyInnermanyOuterCandidatesAmbiguity() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/manyInnermanyOuterCandidatesAmbiguity.kt"); + } + + @Test + @TestMetadata("manyOuterCandidates.kt") + public void testManyOuterCandidates() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/manyOuterCandidates.kt"); + } + + @Test + @TestMetadata("properties.kt") + public void testProperties() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/properties.kt"); + } + + @Test + @TestMetadata("referenceToJavaStdlib.kt") + public void testReferenceToJavaStdlib() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/referenceToJavaStdlib.kt"); + } + + @Test + @TestMetadata("sam.kt") + public void testSam() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/sam.kt"); + } + + @Test + @TestMetadata("simpleClassReceiver.kt") + public void testSimpleClassReceiver() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/simpleClassReceiver.kt"); + } + + @Test + @TestMetadata("simpleExpressionReceiver.kt") + public void testSimpleExpressionReceiver() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/simpleExpressionReceiver.kt"); + } + + @Test + @TestMetadata("simpleNoReceiver.kt") + public void testSimpleNoReceiver() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/simpleNoReceiver.kt"); + } + + @Test + @TestMetadata("varProperties.kt") + public void testVarProperties() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/varProperties.kt"); + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests") + @TestDataPath("$PROJECT_ROOT") + public class FromBasicDiagnosticTests { + @Test + public void testAllFilesPresentInFromBasicDiagnosticTests() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("ambiguityWhenNoApplicableCallableReferenceCandidate.kt") + public void testAmbiguityWhenNoApplicableCallableReferenceCandidate() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/ambiguityWhenNoApplicableCallableReferenceCandidate.kt"); + } + + @Test + @TestMetadata("applicableCallableReferenceFromDistantScope.kt") + public void testApplicableCallableReferenceFromDistantScope() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/applicableCallableReferenceFromDistantScope.kt"); + } + + @Test + @TestMetadata("chooseCallableReferenceDependingOnInferredReceiver.kt") + public void testChooseCallableReferenceDependingOnInferredReceiver() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/chooseCallableReferenceDependingOnInferredReceiver.kt"); + } + + @Test + @TestMetadata("commonSupertypeFromReturnTypesOfCallableReference.kt") + public void testCommonSupertypeFromReturnTypesOfCallableReference() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/commonSupertypeFromReturnTypesOfCallableReference.kt"); + } + + @Test + @TestMetadata("eagerAndPostponedCallableReferences.kt") + public void testEagerAndPostponedCallableReferences() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/eagerAndPostponedCallableReferences.kt"); + } + + @Test + @TestMetadata("eagerResolveOfSingleCallableReference.kt") + public void testEagerResolveOfSingleCallableReference() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/eagerResolveOfSingleCallableReference.kt"); + } + + @Test + @TestMetadata("moreSpecificAmbiguousExtensions.kt") + public void testMoreSpecificAmbiguousExtensions() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/moreSpecificAmbiguousExtensions.kt"); + } + + @Test + @TestMetadata("multipleOutersAndMultipleCallableReferences.kt") + public void testMultipleOutersAndMultipleCallableReferences() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/multipleOutersAndMultipleCallableReferences.kt"); + } + + @Test + @TestMetadata("noAmbiguityBetweenTopLevelAndMemberProperty.kt") + public void testNoAmbiguityBetweenTopLevelAndMemberProperty() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/noAmbiguityBetweenTopLevelAndMemberProperty.kt"); + } + + @Test + @TestMetadata("overloadsBound.kt") + public void testOverloadsBound() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/overloadsBound.kt"); + } + + @Test + @TestMetadata("postponedResolveOfManyCallableReference.kt") + public void testPostponedResolveOfManyCallableReference() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/postponedResolveOfManyCallableReference.kt"); + } + + @Test + @TestMetadata("resolveCallableReferencesAfterAllSimpleArguments.kt") + public void testResolveCallableReferencesAfterAllSimpleArguments() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/resolveCallableReferencesAfterAllSimpleArguments.kt"); + } + + @Test + @TestMetadata("withGenericFun.kt") + public void testWithGenericFun() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests/withGenericFun.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts") + @TestDataPath("$PROJECT_ROOT") + public class Contracts { + @Test + public void testAllFilesPresentInContracts() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromLibrary") + @TestDataPath("$PROJECT_ROOT") + public class FromLibrary { + @Test + public void testAllFilesPresentInFromLibrary() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromLibrary"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("callsInPlace.kt") + public void testCallsInPlace() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromLibrary/callsInPlace.kt"); + } + + @Test + @TestMetadata("conditionalEffects.kt") + public void testConditionalEffects() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromLibrary/conditionalEffects.kt"); + } + + @Test + @TestMetadata("notIsNullOrEmpty.kt") + public void testNotIsNullOrEmpty() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromLibrary/notIsNullOrEmpty.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource") + @TestDataPath("$PROJECT_ROOT") + public class FromSource { + @Test + public void testAllFilesPresentInFromSource() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/bad") + @TestDataPath("$PROJECT_ROOT") + public class Bad { + @Test + public void testAllFilesPresentInBad() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/bad"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("noOptIn.kt") + public void testNoOptIn() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/bad/noOptIn.kt"); + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/bad/callsInPlace") + @TestDataPath("$PROJECT_ROOT") + public class CallsInPlace { + @Test + public void testAllFilesPresentInCallsInPlace() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/bad/callsInPlace"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("inAnonymousObject.kt") + public void testInAnonymousObject() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/bad/callsInPlace/inAnonymousObject.kt"); + } + + @Test + @TestMetadata("inLocalClass.kt") + public void testInLocalClass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/bad/callsInPlace/inLocalClass.kt"); + } + + @Test + @TestMetadata("inLocalFunction.kt") + public void testInLocalFunction() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/bad/callsInPlace/inLocalFunction.kt"); + } + + @Test + @TestMetadata("toLocalVariables.kt") + public void testToLocalVariables() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/bad/callsInPlace/toLocalVariables.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/bad/returnsImplies") + @TestDataPath("$PROJECT_ROOT") + public class ReturnsImplies { + @Test + public void testAllFilesPresentInReturnsImplies() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/bad/returnsImplies"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("notNull.kt") + public void testNotNull() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/bad/returnsImplies/notNull.kt"); + } + + @Test + @TestMetadata("propertyGetter.kt") + public void testPropertyGetter() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/bad/returnsImplies/propertyGetter.kt"); + } + + @Test + @TestMetadata("redundantConditions.kt") + public void testRedundantConditions() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/bad/returnsImplies/redundantConditions.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good") + @TestDataPath("$PROJECT_ROOT") + public class Good { + @Test + public void testAllFilesPresentInGood() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/callsInPlace") + @TestDataPath("$PROJECT_ROOT") + public class CallsInPlace { + @Test + public void testAllFilesPresentInCallsInPlace() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/callsInPlace"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("atLeastOnce.kt") + public void testAtLeastOnce() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/callsInPlace/atLeastOnce.kt"); + } + + @Test + @TestMetadata("atMostOnce.kt") + public void testAtMostOnce() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/callsInPlace/atMostOnce.kt"); + } + + @Test + @TestMetadata("contractsUsage.kt") + public void testContractsUsage() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/callsInPlace/contractsUsage.kt"); + } + + @Test + @TestMetadata("exactlyOnce.kt") + public void testExactlyOnce() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/callsInPlace/exactlyOnce.kt"); + } + + @Test + @TestMetadata("flow.kt") + public void testFlow() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/callsInPlace/flow.kt"); + } + + @Test + @TestMetadata("inPlaceLambda.kt") + public void testInPlaceLambda() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/callsInPlace/inPlaceLambda.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/callsInPlace/simple.kt"); + } + + @Test + @TestMetadata("unknown.kt") + public void testUnknown() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/callsInPlace/unknown.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies") + @TestDataPath("$PROJECT_ROOT") + public class ReturnsImplies { + @Test + public void testAllFilesPresentInReturnsImplies() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("booleanOperators.kt") + public void testBooleanOperators() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/booleanOperators.kt"); + } + + @Test + @TestMetadata("conditionLogic.kt") + public void testConditionLogic() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/conditionLogic.kt"); + } + + @Test + @TestMetadata("eqNotEq.kt") + public void testEqNotEq() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/eqNotEq.kt"); + } + + @Test + @TestMetadata("inapplicable.kt") + public void testInapplicable() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/inapplicable.kt"); + } + + @Test + @TestMetadata("namedArguments.kt") + public void testNamedArguments() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/namedArguments.kt"); + } + + @Test + @TestMetadata("notNull.kt") + public void testNotNull() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/notNull.kt"); + } + + @Test + @TestMetadata("propertyAccessors.kt") + public void testPropertyAccessors() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/propertyAccessors.kt"); + } + + @Test + @TestMetadata("receivers.kt") + public void testReceivers() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/receivers.kt"); + } + + @Test + @TestMetadata("safeCall.kt") + public void testSafeCall() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/safeCall.kt"); + } + + @Test + @TestMetadata("trickyCases.kt") + public void testTrickyCases() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/trickyCases.kt"); + } + + @Test + @TestMetadata("typePredicate.kt") + public void testTypePredicate() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/typePredicate.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/variousContracts") + @TestDataPath("$PROJECT_ROOT") + public class VariousContracts { + @Test + public void testAllFilesPresentInVariousContracts() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/variousContracts"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/variousContracts/newSyntax") + @TestDataPath("$PROJECT_ROOT") + public class NewSyntax { + @Test + public void testAllFilesPresentInNewSyntax() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/variousContracts/newSyntax"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("functionsWithContract.kt") + public void testFunctionsWithContract() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/variousContracts/newSyntax/functionsWithContract.kt"); + } + } + } + } + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates") + @TestDataPath("$PROJECT_ROOT") + public class Delegates { + @Test + public void testAllFilesPresentInDelegates() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("annotationArgumentMapping.kt") + public void testAnnotationArgumentMapping() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/annotationArgumentMapping.kt"); + } + + @Test + @TestMetadata("anonymousInDelegate.kt") + public void testAnonymousInDelegate() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/anonymousInDelegate.kt"); + } + + @Test + @TestMetadata("delegateTypeMismatch.kt") + public void testDelegateTypeMismatch() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/delegateTypeMismatch.kt"); + } + + @Test + @TestMetadata("delegateWithAnonymousObject.kt") + public void testDelegateWithAnonymousObject() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/delegateWithAnonymousObject.kt"); + } + + @Test + @TestMetadata("getClassLet.kt") + public void testGetClassLet() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/getClassLet.kt"); + } + + @Test + @TestMetadata("kt41917.kt") + public void testKt41917() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/kt41917.kt"); + } + + @Test + @TestMetadata("mapValuesLazy.kt") + public void testMapValuesLazy() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/mapValuesLazy.kt"); + } + + @Test + @TestMetadata("nullableTypeDelegate.kt") + public void testNullableTypeDelegate() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/nullableTypeDelegate.kt"); + } + + @Test + @TestMetadata("propertyWithFunctionalType.kt") + public void testPropertyWithFunctionalType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/propertyWithFunctionalType.kt"); + } + + @Test + @TestMetadata("sequentialLazy.kt") + public void testSequentialLazy() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/sequentialLazy.kt"); + } + + @Test + @TestMetadata("simpleDelegateProvider.kt") + public void testSimpleDelegateProvider() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/simpleDelegateProvider.kt"); + } + + @Test + @TestMetadata("simpleDelegatedToMap.kt") + public void testSimpleDelegatedToMap() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/simpleDelegatedToMap.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/diagnostics") + @TestDataPath("$PROJECT_ROOT") + public class Diagnostics { + @Test + public void testAllFilesPresentInDiagnostics() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/diagnostics"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("forLoopChecker.kt") + public void testForLoopChecker() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/diagnostics/forLoopChecker.kt"); + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/diagnostics/functionReturnTypeMismatchChecker") + @TestDataPath("$PROJECT_ROOT") + public class FunctionReturnTypeMismatchChecker { + @Test + public void testAllFilesPresentInFunctionReturnTypeMismatchChecker() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/diagnostics/functionReturnTypeMismatchChecker"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("basic.kt") + public void testBasic() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/diagnostics/functionReturnTypeMismatchChecker/basic.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/diagnostics/initializerTypeMismatchChecker") + @TestDataPath("$PROJECT_ROOT") + public class InitializerTypeMismatchChecker { + @Test + public void testAllFilesPresentInInitializerTypeMismatchChecker() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/diagnostics/initializerTypeMismatchChecker"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("functionType.kt") + public void testFunctionType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/diagnostics/initializerTypeMismatchChecker/functionType.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/inference") + @TestDataPath("$PROJECT_ROOT") + public class Inference { + @Test + public void testAllFilesPresentInInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/inference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("builderInference.kt") + public void testBuilderInference() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/builderInference.kt"); + } + + @Test + @TestMetadata("builderInferenceAndCoercionToUnit.kt") + public void testBuilderInferenceAndCoercionToUnit() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/builderInferenceAndCoercionToUnit.kt"); + } + + @Test + @TestMetadata("builderInferenceFromStdlib.kt") + public void testBuilderInferenceFromStdlib() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/builderInferenceFromStdlib.kt"); + } + + @Test + @TestMetadata("complexConstraintSystem.kt") + public void testComplexConstraintSystem() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/complexConstraintSystem.kt"); + } + + @Test + @TestMetadata("flexibleTypeInSystem.kt") + public void testFlexibleTypeInSystem() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/flexibleTypeInSystem.kt"); + } + + @Test + @TestMetadata("ifElvisReturn.kt") + public void testIfElvisReturn() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/ifElvisReturn.kt"); + } + + @Test + @TestMetadata("plusAssignWithLambdaInRhs.kt") + public void testPlusAssignWithLambdaInRhs() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/plusAssignWithLambdaInRhs.kt"); + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/problems") + @TestDataPath("$PROJECT_ROOT") + public class Problems { + @Test + public void testAllFilesPresentInProblems() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/problems"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("buildList.kt") + public void testBuildList() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/problems/buildList.kt"); + } + + @Test + @TestMetadata("buildListLazy.kt") + public void testBuildListLazy() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/problems/buildListLazy.kt"); + } + + @Test + @TestMetadata("buildSetWithVisitor.kt") + public void testBuildSetWithVisitor() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/problems/buildSetWithVisitor.kt"); + } + + @Test + @TestMetadata("expectedType.kt") + public void testExpectedType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/problems/expectedType.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/initialization") + @TestDataPath("$PROJECT_ROOT") + public class Initialization { + @Test + public void testAllFilesPresentInInitialization() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/initialization"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("fromLocalMembers.kt") + public void testFromLocalMembers() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/initialization/fromLocalMembers.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/intellij") + @TestDataPath("$PROJECT_ROOT") + public class Intellij { + @Test + @TestMetadata("accessInSetter.kt") + public void testAccessInSetter() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/intellij/accessInSetter.kt"); + } + + @Test + public void testAllFilesPresentInIntellij() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/intellij"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("arrayOfImports.kt") + public void testArrayOfImports() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/intellij/arrayOfImports.kt"); + } + + @Test + @TestMetadata("baseIntrospector.kt") + public void testBaseIntrospector() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/intellij/baseIntrospector.kt"); + } + + @Test + @TestMetadata("DailyAggregatedDoubleFactor.kt") + public void testDailyAggregatedDoubleFactor() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/intellij/DailyAggregatedDoubleFactor.kt"); + } + + @Test + @TestMetadata("defaultParameterFromBase.kt") + public void testDefaultParameterFromBase() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/intellij/defaultParameterFromBase.kt"); + } + + @Test + @TestMetadata("EnumWithToString.kt") + public void testEnumWithToString() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/intellij/EnumWithToString.kt"); + } + + @Test + @TestMetadata("FieldVsSyntheticAccessor.kt") + public void testFieldVsSyntheticAccessor() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/intellij/FieldVsSyntheticAccessor.kt"); + } + + @Test + @TestMetadata("hideBySeverity.kt") + public void testHideBySeverity() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/intellij/hideBySeverity.kt"); + } + + @Test + @TestMetadata("InnerClassOfThrowableOnObject.kt") + public void testInnerClassOfThrowableOnObject() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/intellij/InnerClassOfThrowableOnObject.kt"); + } + + @Test + @TestMetadata("IntersectionWithJavaString.kt") + public void testIntersectionWithJavaString() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/intellij/IntersectionWithJavaString.kt"); + } + + @Test + @TestMetadata("lambdaForKfunction.kt") + public void testLambdaForKfunction() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/intellij/lambdaForKfunction.kt"); + } + + @Test + @TestMetadata("ParentOfType.kt") + public void testParentOfType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/intellij/ParentOfType.kt"); + } + + @Test + @TestMetadata("PersistentStateComponent.kt") + public void testPersistentStateComponent() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/intellij/PersistentStateComponent.kt"); + } + + @Test + @TestMetadata("typeAliasAmbiguity.kt") + public void testTypeAliasAmbiguity() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/intellij/typeAliasAmbiguity.kt"); + } + + @Test + @TestMetadata("UastPatterns.kt") + public void testUastPatterns() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/intellij/UastPatterns.kt"); + } + + @Test + @TestMetadata("WithSpeedSearch.kt") + public void testWithSpeedSearch() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/intellij/WithSpeedSearch.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k") + @TestDataPath("$PROJECT_ROOT") + public class J_k { + @Test + public void testAllFilesPresentInJ_k() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("AnnotationWithEnum.kt") + public void testAnnotationWithEnum() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/AnnotationWithEnum.kt"); + } + + @Test + @TestMetadata("BasicWithAnnotatedJava.kt") + public void testBasicWithAnnotatedJava() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/BasicWithAnnotatedJava.kt"); + } + + @Test + @TestMetadata("BasicWithAnnotatedOverriddenJava.kt") + public void testBasicWithAnnotatedOverriddenJava() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/BasicWithAnnotatedOverriddenJava.kt"); + } + + @Test + @TestMetadata("BasicWithJava.kt") + public void testBasicWithJava() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/BasicWithJava.kt"); + } + + @Test + @TestMetadata("BasicWithJavaFakeOverride.kt") + public void testBasicWithJavaFakeOverride() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/BasicWithJavaFakeOverride.kt"); + } + + @Test + @TestMetadata("BasicWithPrimitiveJava.kt") + public void testBasicWithPrimitiveJava() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/BasicWithPrimitiveJava.kt"); + } + + @Test + @TestMetadata("capturedFlexible.kt") + public void testCapturedFlexible() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/capturedFlexible.kt"); + } + + @Test + @TestMetadata("complexFlexibleInference.kt") + public void testComplexFlexibleInference() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/complexFlexibleInference.kt"); + } + + @Test + @TestMetadata("FieldAccessFromDerived.kt") + public void testFieldAccessFromDerived() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/FieldAccessFromDerived.kt"); + } + + @Test + @TestMetadata("FieldAndGetter.kt") + public void testFieldAndGetter() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/FieldAndGetter.kt"); + } + + @Test + @TestMetadata("fieldOverride.kt") + public void testFieldOverride() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/fieldOverride.kt"); + } + + @Test + @TestMetadata("FieldSubstitution.kt") + public void testFieldSubstitution() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/FieldSubstitution.kt"); + } + + @Test + @TestMetadata("FlexiblePrimitiveOverloading.kt") + public void testFlexiblePrimitiveOverloading() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/FlexiblePrimitiveOverloading.kt"); + } + + @Test + @TestMetadata("flexibleTypeAliases.kt") + public void testFlexibleTypeAliases() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/flexibleTypeAliases.kt"); + } + + @Test + @TestMetadata("FunctionTypeInJava.kt") + public void testFunctionTypeInJava() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/FunctionTypeInJava.kt"); + } + + @Test + @TestMetadata("IntersectionTypesProblem.kt") + public void testIntersectionTypesProblem() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/IntersectionTypesProblem.kt"); + } + + @Test + @TestMetadata("JavaGetPrefixConflict.kt") + public void testJavaGetPrefixConflict() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/JavaGetPrefixConflict.kt"); + } + + @Test + @TestMetadata("JavaInheritsKotlinDerived.kt") + public void testJavaInheritsKotlinDerived() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/JavaInheritsKotlinDerived.kt"); + } + + @Test + @TestMetadata("JavaInheritsKotlinExtension.kt") + public void testJavaInheritsKotlinExtension() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/JavaInheritsKotlinExtension.kt"); + } + + @Test + @TestMetadata("JavaInheritsKotlinProperty.kt") + public void testJavaInheritsKotlinProperty() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/JavaInheritsKotlinProperty.kt"); + } + + @Test + @TestMetadata("JavaInheritsRawKotlin.kt") + public void testJavaInheritsRawKotlin() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/JavaInheritsRawKotlin.kt"); + } + + @Test + @TestMetadata("JavaSyntheticProperty.kt") + public void testJavaSyntheticProperty() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/JavaSyntheticProperty.kt"); + } + + @Test + @TestMetadata("JavaVisibility2.kt") + public void testJavaVisibility2() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/JavaVisibility2.kt"); + } + + @Test + @TestMetadata("KJKComplexHierarchy.kt") + public void testKJKComplexHierarchy() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/KJKComplexHierarchy.kt"); + } + + @Test + @TestMetadata("KJKComplexHierarchyWithNested.kt") + public void testKJKComplexHierarchyWithNested() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/KJKComplexHierarchyWithNested.kt"); + } + + @Test + @TestMetadata("KJKInheritance.kt") + public void testKJKInheritance() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/KJKInheritance.kt"); + } + + @Test + @TestMetadata("KJKInheritanceGeneric.kt") + public void testKJKInheritanceGeneric() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/KJKInheritanceGeneric.kt"); + } + + @Test + @TestMetadata("KotlinClassParameter.kt") + public void testKotlinClassParameter() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/KotlinClassParameter.kt"); + } + + @Test + @TestMetadata("KotlinClassParameterGeneric.kt") + public void testKotlinClassParameterGeneric() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/KotlinClassParameterGeneric.kt"); + } + + @Test + @TestMetadata("kt39076.kt") + public void testKt39076() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/kt39076.kt"); + } + + @Test + @TestMetadata("LoggerInstance.kt") + public void testLoggerInstance() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/LoggerInstance.kt"); + } + + @Test + @TestMetadata("MapCompute.kt") + public void testMapCompute() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/MapCompute.kt"); + } + + @Test + @TestMetadata("MapEntry.kt") + public void testMapEntry() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/MapEntry.kt"); + } + + @Test + @TestMetadata("mapMerge.kt") + public void testMapMerge() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/mapMerge.kt"); + } + + @Test + @TestMetadata("MyException.kt") + public void testMyException() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/MyException.kt"); + } + + @Test + @TestMetadata("MyIterable.kt") + public void testMyIterable() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/MyIterable.kt"); + } + + @Test + @TestMetadata("MyMap.kt") + public void testMyMap() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/MyMap.kt"); + } + + @Test + @TestMetadata("outerInnerClasses.kt") + public void testOuterInnerClasses() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/outerInnerClasses.kt"); + } + + @Test + @TestMetadata("OverrideWithJava.kt") + public void testOverrideWithJava() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/OverrideWithJava.kt"); + } + + @Test + @TestMetadata("RawType.kt") + public void testRawType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/RawType.kt"); + } + + @Test + @TestMetadata("serializableString.kt") + public void testSerializableString() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/serializableString.kt"); + } + + @Test + @TestMetadata("smartSet.kt") + public void testSmartSet() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/smartSet.kt"); + } + + @Test + @TestMetadata("StaticClassConstructorFromBaseClass.kt") + public void testStaticClassConstructorFromBaseClass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/StaticClassConstructorFromBaseClass.kt"); + } + + @Test + @TestMetadata("StaticFromBaseClass.kt") + public void testStaticFromBaseClass() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/StaticFromBaseClass.kt"); + } + + @Test + @TestMetadata("StaticGenericMethod.kt") + public void testStaticGenericMethod() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/StaticGenericMethod.kt"); + } + + @Test + @TestMetadata("SyntheticAfterFiltering.kt") + public void testSyntheticAfterFiltering() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/SyntheticAfterFiltering.kt"); + } + + @Test + @TestMetadata("SyntheticWithForEach.kt") + public void testSyntheticWithForEach() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/SyntheticWithForEach.kt"); + } + + @Test + @TestMetadata("typeParameterUse.kt") + public void testTypeParameterUse() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/typeParameterUse.kt"); + } + + @Test + @TestMetadata("UsingObject.kt") + public void testUsingObject() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/UsingObject.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/multiModule") + @TestDataPath("$PROJECT_ROOT") + public class MultiModule { + @Test + public void testAllFilesPresentInMultiModule() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/multiModule"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("Basic.kt") + public void testBasic() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/multiModule/Basic.kt"); + } + + @Test + @TestMetadata("FakeOverrides.kt") + public void testFakeOverrides() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/multiModule/FakeOverrides.kt"); + } + + @Test + @TestMetadata("MemberType.kt") + public void testMemberType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/multiModule/MemberType.kt"); + } + + @Test + @TestMetadata("Members.kt") + public void testMembers() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/multiModule/Members.kt"); + } + + @Test + @TestMetadata("SuperTypes.kt") + public void testSuperTypes() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/multiModule/SuperTypes.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems") + @TestDataPath("$PROJECT_ROOT") + public class Problems { + @Test + @TestMetadata("AbstractToolConfig.kt") + public void testAbstractToolConfig() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/AbstractToolConfig.kt"); + } + + @Test + public void testAllFilesPresentInProblems() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("argumentTypeMismatch.kt") + public void testArgumentTypeMismatch() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/argumentTypeMismatch.kt"); + } + + @Test + @TestMetadata("capturedTypeInEquality.kt") + public void testCapturedTypeInEquality() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/capturedTypeInEquality.kt"); + } + + @Test + @TestMetadata("classCastWithRawKotlinType.kt") + public void testClassCastWithRawKotlinType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/classCastWithRawKotlinType.kt"); + } + + @Test + @TestMetadata("DeepCopyIrTree.kt") + public void testDeepCopyIrTree() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/DeepCopyIrTree.kt"); + } + + @Test + @TestMetadata("definitelyNotNullCast.kt") + public void testDefinitelyNotNullCast() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/definitelyNotNullCast.kt"); + } + + @Test + @TestMetadata("EnumMapGet.kt") + public void testEnumMapGet() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/EnumMapGet.kt"); + } + + @Test + @TestMetadata("exceptionInRepeatedAnnotation.kt") + public void testExceptionInRepeatedAnnotation() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/exceptionInRepeatedAnnotation.kt"); + } + + @Test + @TestMetadata("falseSamConversion.kt") + public void testFalseSamConversion() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/falseSamConversion.kt"); + } + + @Test + @TestMetadata("immutableName.kt") + public void testImmutableName() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/immutableName.kt"); + } + + @Test + @TestMetadata("invokePriority.kt") + public void testInvokePriority() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/invokePriority.kt"); + } + + @Test + @TestMetadata("invokePriorityComplex.kt") + public void testInvokePriorityComplex() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/invokePriorityComplex.kt"); + } + + @Test + @TestMetadata("isAncestor.kt") + public void testIsAncestor() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/isAncestor.kt"); + } + + @Test + @TestMetadata("KJKComplexHierarchyNestedLoop.kt") + public void testKJKComplexHierarchyNestedLoop() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/KJKComplexHierarchyNestedLoop.kt"); + } + + @Test + @TestMetadata("KtFirCompositeScope.kt") + public void testKtFirCompositeScope() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/KtFirCompositeScope.kt"); + } + + @Test + @TestMetadata("lightMember.kt") + public void testLightMember() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/lightMember.kt"); + } + + @Test + @TestMetadata("localScopesInAnonymousObject.kt") + public void testLocalScopesInAnonymousObject() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/localScopesInAnonymousObject.kt"); + } + + @Test + @TestMetadata("NamedParameterInConcurrentMap.kt") + public void testNamedParameterInConcurrentMap() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/NamedParameterInConcurrentMap.kt"); + } + + @Test + @TestMetadata("qualifierPriority.kt") + public void testQualifierPriority() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/qualifierPriority.kt"); + } + + @Test + @TestMetadata("receiverResolutionInLambda.kt") + public void testReceiverResolutionInLambda() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/receiverResolutionInLambda.kt"); + } + + @Test + @TestMetadata("resolveToLocalFromCallSite.kt") + public void testResolveToLocalFromCallSite() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/resolveToLocalFromCallSite.kt"); + } + + @Test + @TestMetadata("selfReferenceToCompanionObject.kt") + public void testSelfReferenceToCompanionObject() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/selfReferenceToCompanionObject.kt"); + } + + @Test + @TestMetadata("SpecialCallsWithLambdas.kt") + public void testSpecialCallsWithLambdas() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/SpecialCallsWithLambdas.kt"); + } + + @Test + @TestMetadata("stringConstructors.kt") + public void testStringConstructors() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/stringConstructors.kt"); + } + + @Test + @TestMetadata("TypesEligibleForSimpleVisit.kt") + public void testTypesEligibleForSimpleVisit() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/TypesEligibleForSimpleVisit.kt"); + } + + @Test + @TestMetadata("valueOfOrNull.kt") + public void testValueOfOrNull() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/valueOfOrNull.kt"); + } + + @Test + @TestMetadata("weakHashMap.kt") + public void testWeakHashMap() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/weakHashMap.kt"); + } + + @Test + @TestMetadata("WithValidityAssertion.kt") + public void testWithValidityAssertion() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/WithValidityAssertion.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/properties") + @TestDataPath("$PROJECT_ROOT") + public class Properties { + @Test + public void testAllFilesPresentInProperties() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/properties"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("explicitBackingFieldUnsupported.kt") + public void testExplicitBackingFieldUnsupported() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/explicitBackingFieldUnsupported.kt"); + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField") + @TestDataPath("$PROJECT_ROOT") + public class BackingField { + @Test + public void testAllFilesPresentInBackingField() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("backingFieldModifiers.kt") + public void testBackingFieldModifiers() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/backingFieldModifiers.kt"); + } + + @Test + @TestMetadata("backingFieldVisibility.kt") + public void testBackingFieldVisibility() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/backingFieldVisibility.kt"); + } + + @Test + @TestMetadata("backingFieldWithSmartTypeParameters.kt") + public void testBackingFieldWithSmartTypeParameters() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/backingFieldWithSmartTypeParameters.kt"); + } + + @Test + @TestMetadata("explicitBackingFieldInInterface.kt") + public void testExplicitBackingFieldInInterface() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/explicitBackingFieldInInterface.kt"); + } + + @Test + @TestMetadata("explicitBackingFieldType.kt") + public void testExplicitBackingFieldType() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/explicitBackingFieldType.kt"); + } + + @Test + @TestMetadata("explicitBackingFieldsWithDelegates.kt") + public void testExplicitBackingFieldsWithDelegates() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/explicitBackingFieldsWithDelegates.kt"); + } + + @Test + @TestMetadata("filePrivateBackingFieldAccess.kt") + public void testFilePrivateBackingFieldAccess() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/filePrivateBackingFieldAccess.kt"); + } + + @Test + @TestMetadata("lateinitBackingFields.kt") + public void testLateinitBackingFields() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/lateinitBackingFields.kt"); + } + + @Test + @TestMetadata("localVariablesWithBackingFields.kt") + public void testLocalVariablesWithBackingFields() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/localVariablesWithBackingFields.kt"); + } + + @Test + @TestMetadata("overriddenPropertiesWithExplicitBackingFields.kt") + public void testOverriddenPropertiesWithExplicitBackingFields() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/overriddenPropertiesWithExplicitBackingFields.kt"); + } + + @Test + @TestMetadata("propertyTypeNarrowing.kt") + public void testPropertyTypeNarrowing() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/propertyTypeNarrowing.kt"); + } + + @Test + @TestMetadata("randomWeirdBackingFields.kt") + public void testRandomWeirdBackingFields() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/randomWeirdBackingFields.kt"); + } + + @Test + @TestMetadata("redundantExplicitBackingField.kt") + public void testRedundantExplicitBackingField() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/redundantExplicitBackingField.kt"); + } + + @Test + @TestMetadata("untypedPropertyWithBackingFieldUsage.kt") + public void testUntypedPropertyWithBackingFieldUsage() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/untypedPropertyWithBackingFieldUsage.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/reinitializations") + @TestDataPath("$PROJECT_ROOT") + public class Reinitializations { + @Test + public void testAllFilesPresentInReinitializations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/reinitializations"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("constructorVarWrite.kt") + public void testConstructorVarWrite() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/reinitializations/constructorVarWrite.kt"); + } + } + + @Nested + @TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/smartcasts") + @TestDataPath("$PROJECT_ROOT") + public class Smartcasts { + @Test + public void testAllFilesPresentInSmartcasts() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/smartcasts"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("assertIs.kt") + public void testAssertIs() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/smartcasts/assertIs.kt"); + } + + @Test + @TestMetadata("tryWithLambdaInside.kt") + public void testTryWithLambdaInside() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/smartcasts/tryWithLambdaInside.kt"); + } + } + } +} diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/PreFirIdeSpecTestGenerated.java b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/PreFirIdeSpecTestGenerated.java new file mode 100644 index 00000000000..ddd7e21c20e --- /dev/null +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/PreFirIdeSpecTestGenerated.java @@ -0,0 +1,7650 @@ +/* + * 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.analysis.low.level.api.fir.diagnostic.compiler.based; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +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.analysis.api.GenerateAnalysisApiTestsKt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("compiler/tests-spec/testData/diagnostics") +@TestDataPath("$PROJECT_ROOT") +public class PreFirIdeSpecTestGenerated extends AbstractLLFirPreresolvedReversedDiagnosticCompilerTestDataSpecTest { + @Test + public void testAllFilesPresentInDiagnostics() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "helpers", "linked/annotations", "linked/built-in-types-and-their-semantics", "linked/control--and-data-flow-analysis.control-flow-graph.expressions-1.conditional-expressions", "linked/control--and-data-flow-analysis/performing-analysis-on-the-control-flow-graph", "linked/declarations/classifier-declaration/class-declaration/nested-and-inner-classifiers", "linked/declarations/classifier-declaration/classifier-initialization", "linked/declarations/classifier-declaration/data-class-declaration", "linked/declarations/function-declaration", "linked/declarations/property-declaration/property-initialization", "linked/declarations/type-alias", "linked/expressions/call-and-property-access-expressions", "linked/expressions/function-literals", "linked/inheritance", "linked/overload-resolution/c-level-partition", "linked/overload-resolution/determining-function-applicability-for-a-specific-call/rationale", "linked/overloadable-operators", "linked/statements/assignments/simple-assignments", "linked/type-inference/local-type-inference", "linked/type-inference/smart-casts/smart-cast-types", "linked/type-system/subtyping/subtyping-for-nullable-types", "linked/type-system/type-kinds/type-parameters"); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked") + @TestDataPath("$PROJECT_ROOT") + public class Linked { + @Test + public void testAllFilesPresentInLinked() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "annotations", "built-in-types-and-their-semantics", "control--and-data-flow-analysis.control-flow-graph.expressions-1.conditional-expressions", "control--and-data-flow-analysis/performing-analysis-on-the-control-flow-graph", "declarations/classifier-declaration/class-declaration/nested-and-inner-classifiers", "declarations/classifier-declaration/classifier-initialization", "declarations/classifier-declaration/data-class-declaration", "declarations/function-declaration", "declarations/property-declaration/property-initialization", "declarations/type-alias", "expressions/call-and-property-access-expressions", "expressions/function-literals", "inheritance", "overload-resolution/c-level-partition", "overload-resolution/determining-function-applicability-for-a-specific-call/rationale", "overloadable-operators", "statements/assignments/simple-assignments", "type-inference/local-type-inference", "type-inference/smart-casts/smart-cast-types", "type-system/subtyping/subtyping-for-nullable-types", "type-system/type-kinds/type-parameters"); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis") + @TestDataPath("$PROJECT_ROOT") + public class Control__and_data_flow_analysis { + @Test + public void testAllFilesPresentInControl__and_data_flow_analysis() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "performing-analysis-on-the-control-flow-graph"); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph") + @TestDataPath("$PROJECT_ROOT") + public class Control_flow_graph { + @Test + public void testAllFilesPresentInControl_flow_graph() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1") + @TestDataPath("$PROJECT_ROOT") + public class Expressions_1 { + @Test + public void testAllFilesPresentInExpressions_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions") + @TestDataPath("$PROJECT_ROOT") + public class Conditional_expressions { + @Test + public void testAllFilesPresentInConditional_expressions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1/neg/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1/neg/1.2.kt"); + } + + @Test + @TestMetadata("1.3.kt") + public void test1_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1/neg/1.3.kt"); + } + + @Test + @TestMetadata("1.4.kt") + public void test1_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1/neg/1.4.kt"); + } + + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1/neg/2.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1/pos/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1/pos/1.2.kt"); + } + + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1/pos/2.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations") + @TestDataPath("$PROJECT_ROOT") + public class Declarations { + @Test + public void testAllFilesPresentInDeclarations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "classifier-declaration/class-declaration/nested-and-inner-classifiers", "classifier-declaration/classifier-initialization", "classifier-declaration/data-class-declaration", "function-declaration", "property-declaration/property-initialization", "type-alias"); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration") + @TestDataPath("$PROJECT_ROOT") + public class Classifier_declaration { + @Test + public void testAllFilesPresentInClassifier_declaration() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "class-declaration/nested-and-inner-classifiers", "classifier-initialization", "data-class-declaration"); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration") + @TestDataPath("$PROJECT_ROOT") + public class Class_declaration { + @Test + public void testAllFilesPresentInClass_declaration() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "nested-and-inner-classifiers"); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes") + @TestDataPath("$PROJECT_ROOT") + public class Abstract_classes { + @Test + public void testAllFilesPresentInAbstract_classes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1/neg/1.1.kt"); + } + + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1/neg/2.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1/pos/2.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2") + @TestDataPath("$PROJECT_ROOT") + public class P_2 { + @Test + public void testAllFilesPresentInP_2() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.1.kt"); + } + + @Test + @TestMetadata("1.10.kt") + public void test1_10() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.10.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.2.kt"); + } + + @Test + @TestMetadata("1.3.kt") + public void test1_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.3.kt"); + } + + @Test + @TestMetadata("1.4.kt") + public void test1_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.4.kt"); + } + + @Test + @TestMetadata("1.5.kt") + public void test1_5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.5.kt"); + } + + @Test + @TestMetadata("1.6.kt") + public void test1_6() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.6.kt"); + } + + @Test + @TestMetadata("1.7.kt") + public void test1_7() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.7.kt"); + } + + @Test + @TestMetadata("1.8.kt") + public void test1_8() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.8.kt"); + } + + @Test + @TestMetadata("1.9.kt") + public void test1_9() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.9.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/pos/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/pos/1.2.kt"); + } + + @Test + @TestMetadata("1.3.kt") + public void test1_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/pos/1.3.kt"); + } + + @Test + @TestMetadata("1.4.kt") + public void test1_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/pos/1.4.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration") + @TestDataPath("$PROJECT_ROOT") + public class Constructor_declaration { + @Test + public void testAllFilesPresentInConstructor_declaration() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-4") + @TestDataPath("$PROJECT_ROOT") + public class P_4 { + @Test + public void testAllFilesPresentInP_4() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-4/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-4/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5") + @TestDataPath("$PROJECT_ROOT") + public class P_5 { + @Test + public void testAllFilesPresentInP_5() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg/1.2.kt"); + } + + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg/2.1.kt"); + } + + @Test + @TestMetadata("3.1.kt") + public void test3_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg/3.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/1.2.kt"); + } + + @Test + @TestMetadata("1.3.kt") + public void test1_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/1.3.kt"); + } + + @Test + @TestMetadata("1.4.kt") + public void test1_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/1.4.kt"); + } + + @Test + @TestMetadata("1.5.kt") + public void test1_5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/1.5.kt"); + } + + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/2.1.kt"); + } + + @Test + @TestMetadata("2.2.kt") + public void test2_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/2.2.kt"); + } + + @Test + @TestMetadata("2.3.kt") + public void test2_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/2.3.kt"); + } + + @Test + @TestMetadata("2.4.kt") + public void test2_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/2.4.kt"); + } + + @Test + @TestMetadata("3.1.kt") + public void test3_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/3.1.kt"); + } + + @Test + @TestMetadata("3.2.kt") + public void test3_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/3.2.kt"); + } + + @Test + @TestMetadata("3.3.kt") + public void test3_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/3.3.kt"); + } + + @Test + @TestMetadata("3.4.kt") + public void test3_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/3.4.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration") + @TestDataPath("$PROJECT_ROOT") + public class Property_declaration { + @Test + public void testAllFilesPresentInProperty_declaration() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "property-initialization"); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration/local-property-declaration") + @TestDataPath("$PROJECT_ROOT") + public class Local_property_declaration { + @Test + public void testAllFilesPresentInLocal_property_declaration() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration/local-property-declaration"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration/local-property-declaration/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration/local-property-declaration/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration/local-property-declaration/p-1/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration/local-property-declaration/p-1/neg/1.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration/local-property-declaration/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions") + @TestDataPath("$PROJECT_ROOT") + public class Expressions { + @Test + public void testAllFilesPresentInExpressions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "call-and-property-access-expressions", "function-literals"); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression") + @TestDataPath("$PROJECT_ROOT") + public class Additive_expression { + @Test + public void testAllFilesPresentInAdditive_expression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression/p-4") + @TestDataPath("$PROJECT_ROOT") + public class P_4 { + @Test + public void testAllFilesPresentInP_4() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression/p-4/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression/p-4/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics") + @TestDataPath("$PROJECT_ROOT") + public class Built_in_types_and_their_semantics { + @Test + public void testAllFilesPresentInBuilt_in_types_and_their_semantics() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1") + @TestDataPath("$PROJECT_ROOT") + public class Kotlin_nothing_1 { + @Test + public void testAllFilesPresentInKotlin_nothing_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.unit") + @TestDataPath("$PROJECT_ROOT") + public class Kotlin_unit { + @Test + public void testAllFilesPresentInKotlin_unit() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.unit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions") + @TestDataPath("$PROJECT_ROOT") + public class Comparison_expressions { + @Test + public void testAllFilesPresentInComparison_expressions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-1/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-1/neg/2.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-4") + @TestDataPath("$PROJECT_ROOT") + public class P_4 { + @Test + public void testAllFilesPresentInP_4() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-4/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-4/neg/1.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-5") + @TestDataPath("$PROJECT_ROOT") + public class P_5 { + @Test + public void testAllFilesPresentInP_5() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-5/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-5/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression") + @TestDataPath("$PROJECT_ROOT") + public class Conditional_expression { + @Test + public void testAllFilesPresentInConditional_expression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6") + @TestDataPath("$PROJECT_ROOT") + public class P_6 { + @Test + public void testAllFilesPresentInP_6() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6/neg/1.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals") + @TestDataPath("$PROJECT_ROOT") + public class Constant_literals { + @Test + public void testAllFilesPresentInConstant_literals() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals") + @TestDataPath("$PROJECT_ROOT") + public class Boolean_literals { + @Test + public void testAllFilesPresentInBoolean_literals() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1/neg/2.1.kt"); + } + + @Test + @TestMetadata("3.1.kt") + public void test3_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1/neg/3.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1/pos/2.1.kt"); + } + + @Test + @TestMetadata("3.1.kt") + public void test3_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1/pos/3.1.kt"); + } + + @Test + @TestMetadata("3.2.kt") + public void test3_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1/pos/3.2.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals") + @TestDataPath("$PROJECT_ROOT") + public class Character_literals { + @Test + public void testAllFilesPresentInCharacter_literals() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-1/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-1/neg/1.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-1/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-1/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-4") + @TestDataPath("$PROJECT_ROOT") + public class P_4 { + @Test + public void testAllFilesPresentInP_4() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-4/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-4/neg/1.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-4/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-4/pos/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-4/pos/1.2.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals") + @TestDataPath("$PROJECT_ROOT") + public class Integer_literals { + @Test + public void testAllFilesPresentInInteger_literals() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals") + @TestDataPath("$PROJECT_ROOT") + public class Binary_integer_literals { + @Test + public void testAllFilesPresentInBinary_integer_literals() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/neg/1.1.kt"); + } + + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/neg/2.1.kt"); + } + + @Test + @TestMetadata("2.2.kt") + public void test2_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/neg/2.2.kt"); + } + + @Test + @TestMetadata("2.3.kt") + public void test2_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/neg/2.3.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/decimal-integer-literals") + @TestDataPath("$PROJECT_ROOT") + public class Decimal_integer_literals { + @Test + public void testAllFilesPresentInDecimal_integer_literals() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/decimal-integer-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/neg/2.1.kt"); + } + + @Test + @TestMetadata("2.2.kt") + public void test2_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/neg/2.2.kt"); + } + + @Test + @TestMetadata("2.3.kt") + public void test2_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/neg/2.3.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals") + @TestDataPath("$PROJECT_ROOT") + public class Hexadecimal_integer_literals { + @Test + public void testAllFilesPresentInHexadecimal_integer_literals() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/neg/1.1.kt"); + } + + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/neg/2.1.kt"); + } + + @Test + @TestMetadata("2.2.kt") + public void test2_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/neg/2.2.kt"); + } + + @Test + @TestMetadata("2.3.kt") + public void test2_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/neg/2.3.kt"); + } + + @Test + @TestMetadata("2.4.kt") + public void test2_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/neg/2.4.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals") + @TestDataPath("$PROJECT_ROOT") + public class Real_literals { + @Test + public void testAllFilesPresentInReal_literals() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1/neg/1.1.kt"); + } + + @Test + @TestMetadata("3.1.kt") + public void test3_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1/neg/3.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1/pos/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1/pos/1.2.kt"); + } + + @Test + @TestMetadata("3.1.kt") + public void test3_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1/pos/3.1.kt"); + } + + @Test + @TestMetadata("3.2.kt") + public void test3_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1/pos/3.2.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2") + @TestDataPath("$PROJECT_ROOT") + public class P_2 { + @Test + public void testAllFilesPresentInP_2() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2/neg/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2/neg/1.2.kt"); + } + + @Test + @TestMetadata("1.3.kt") + public void test1_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2/neg/1.3.kt"); + } + + @Test + @TestMetadata("1.4.kt") + public void test1_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2/neg/1.4.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2/pos/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2/pos/1.2.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3") + @TestDataPath("$PROJECT_ROOT") + public class P_3 { + @Test + public void testAllFilesPresentInP_3() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3/neg/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3/neg/1.2.kt"); + } + + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3/neg/2.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3/pos/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3/pos/1.2.kt"); + } + + @Test + @TestMetadata("1.3.kt") + public void test1_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3/pos/1.3.kt"); + } + + @Test + @TestMetadata("1.4.kt") + public void test1_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3/pos/1.4.kt"); + } + + @Test + @TestMetadata("1.5.kt") + public void test1_5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3/pos/1.5.kt"); + } + + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3/pos/2.1.kt"); + } + + @Test + @TestMetadata("2.2.kt") + public void test2_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3/pos/2.2.kt"); + } + + @Test + @TestMetadata("2.3.kt") + public void test2_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3/pos/2.3.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4") + @TestDataPath("$PROJECT_ROOT") + public class P_4 { + @Test + public void testAllFilesPresentInP_4() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4/neg/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4/neg/1.2.kt"); + } + + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4/neg/2.1.kt"); + } + + @Test + @TestMetadata("2.2.kt") + public void test2_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4/neg/2.2.kt"); + } + + @Test + @TestMetadata("2.3.kt") + public void test2_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4/neg/2.3.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4/pos/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4/pos/1.2.kt"); + } + + @Test + @TestMetadata("1.3.kt") + public void test1_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4/pos/1.3.kt"); + } + + @Test + @TestMetadata("1.4.kt") + public void test1_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4/pos/1.4.kt"); + } + + @Test + @TestMetadata("1.5.kt") + public void test1_5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4/pos/1.5.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-5") + @TestDataPath("$PROJECT_ROOT") + public class P_5 { + @Test + public void testAllFilesPresentInP_5() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-5/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-5/pos/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-5/pos/1.2.kt"); + } + + @Test + @TestMetadata("1.3.kt") + public void test1_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-5/pos/1.3.kt"); + } + + @Test + @TestMetadata("1.4.kt") + public void test1_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-5/pos/1.4.kt"); + } + + @Test + @TestMetadata("1.5.kt") + public void test1_5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-5/pos/1.5.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals") + @TestDataPath("$PROJECT_ROOT") + public class The_types_for_integer_literals { + @Test + public void testAllFilesPresentInThe_types_for_integer_literals() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/1.2.kt"); + } + + @Test + @TestMetadata("1.3.kt") + public void test1_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/1.3.kt"); + } + + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/2.1.kt"); + } + + @Test + @TestMetadata("2.2.kt") + public void test2_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/2.2.kt"); + } + + @Test + @TestMetadata("2.3.kt") + public void test2_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/2.3.kt"); + } + + @Test + @TestMetadata("2.4.kt") + public void test2_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/2.4.kt"); + } + + @Test + @TestMetadata("2.5.kt") + public void test2_5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/2.5.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/pos/2.1.kt"); + } + + @Test + @TestMetadata("2.2.kt") + public void test2_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/pos/2.2.kt"); + } + + @Test + @TestMetadata("2.3.kt") + public void test2_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/pos/2.3.kt"); + } + + @Test + @TestMetadata("2.4.kt") + public void test2_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/pos/2.4.kt"); + } + + @Test + @TestMetadata("2.5.kt") + public void test2_5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/pos/2.5.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/elvis-operator-expression") + @TestDataPath("$PROJECT_ROOT") + public class Elvis_operator_expression { + @Test + public void testAllFilesPresentInElvis_operator_expression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/elvis-operator-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/elvis-operator-expression/p-3") + @TestDataPath("$PROJECT_ROOT") + public class P_3 { + @Test + public void testAllFilesPresentInP_3() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/elvis-operator-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/elvis-operator-expression/p-3/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/elvis-operator-expression/p-3/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/elvis-operator-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions") + @TestDataPath("$PROJECT_ROOT") + public class Equality_expressions { + @Test + public void testAllFilesPresentInEquality_expressions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions/value-equality-expressions") + @TestDataPath("$PROJECT_ROOT") + public class Value_equality_expressions { + @Test + public void testAllFilesPresentInValue_equality_expressions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions/value-equality-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions/value-equality-expressions/p-3") + @TestDataPath("$PROJECT_ROOT") + public class P_3 { + @Test + public void testAllFilesPresentInP_3() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions/value-equality-expressions/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions/value-equality-expressions/p-3/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions/value-equality-expressions/p-3/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions/value-equality-expressions/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions") + @TestDataPath("$PROJECT_ROOT") + public class Jump_expressions { + @Test + public void testAllFilesPresentInJump_expressions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression") + @TestDataPath("$PROJECT_ROOT") + public class Break_expression { + @Test + public void testAllFilesPresentInBreak_expression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression/p-1/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression/p-1/neg/1.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/continue-expression") + @TestDataPath("$PROJECT_ROOT") + public class Continue_expression { + @Test + public void testAllFilesPresentInContinue_expression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/continue-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/continue-expression/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/continue-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/continue-expression/p-1/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/continue-expression/p-1/neg/1.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/continue-expression/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/p-2") + @TestDataPath("$PROJECT_ROOT") + public class P_2 { + @Test + public void testAllFilesPresentInP_2() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/p-2/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/p-2/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions") + @TestDataPath("$PROJECT_ROOT") + public class Return_expressions { + @Test + public void testAllFilesPresentInReturn_expressions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-1/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-1/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-4") + @TestDataPath("$PROJECT_ROOT") + public class P_4 { + @Test + public void testAllFilesPresentInP_4() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-4/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-4/neg/1.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression") + @TestDataPath("$PROJECT_ROOT") + public class Logical_conjunction_expression { + @Test + public void testAllFilesPresentInLogical_conjunction_expression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2") + @TestDataPath("$PROJECT_ROOT") + public class P_2 { + @Test + public void testAllFilesPresentInP_2() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/neg/1.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression") + @TestDataPath("$PROJECT_ROOT") + public class Logical_disjunction_expression { + @Test + public void testAllFilesPresentInLogical_disjunction_expression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2") + @TestDataPath("$PROJECT_ROOT") + public class P_2 { + @Test + public void testAllFilesPresentInP_2() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/neg/1.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/multiplicative-expression") + @TestDataPath("$PROJECT_ROOT") + public class Multiplicative_expression { + @Test + public void testAllFilesPresentInMultiplicative_expression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/multiplicative-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/multiplicative-expression/p-5") + @TestDataPath("$PROJECT_ROOT") + public class P_5 { + @Test + public void testAllFilesPresentInP_5() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/multiplicative-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/multiplicative-expression/p-5/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/multiplicative-expression/p-5/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/multiplicative-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression") + @TestDataPath("$PROJECT_ROOT") + public class Not_null_assertion_expression { + @Test + public void testAllFilesPresentInNot_null_assertion_expression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-2") + @TestDataPath("$PROJECT_ROOT") + public class P_2 { + @Test + public void testAllFilesPresentInP_2() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-2/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-2/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-3") + @TestDataPath("$PROJECT_ROOT") + public class P_3 { + @Test + public void testAllFilesPresentInP_3() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-3/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-3/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions") + @TestDataPath("$PROJECT_ROOT") + public class Prefix_expressions { + @Test + public void testAllFilesPresentInPrefix_expressions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/logical-not-expression") + @TestDataPath("$PROJECT_ROOT") + public class Logical_not_expression { + @Test + public void testAllFilesPresentInLogical_not_expression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/logical-not-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/logical-not-expression/p-3") + @TestDataPath("$PROJECT_ROOT") + public class P_3 { + @Test + public void testAllFilesPresentInP_3() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/logical-not-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/logical-not-expression/p-3/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/logical-not-expression/p-3/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/logical-not-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression") + @TestDataPath("$PROJECT_ROOT") + public class Prefix_decrement_expression { + @Test + public void testAllFilesPresentInPrefix_decrement_expression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-4") + @TestDataPath("$PROJECT_ROOT") + public class P_4 { + @Test + public void testAllFilesPresentInP_4() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-4/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-4/neg/1.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-5") + @TestDataPath("$PROJECT_ROOT") + public class P_5 { + @Test + public void testAllFilesPresentInP_5() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-5/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-5/neg/2.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression") + @TestDataPath("$PROJECT_ROOT") + public class Prefix_increment_expression { + @Test + public void testAllFilesPresentInPrefix_increment_expression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4") + @TestDataPath("$PROJECT_ROOT") + public class P_4 { + @Test + public void testAllFilesPresentInP_4() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/neg/1.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5") + @TestDataPath("$PROJECT_ROOT") + public class P_5 { + @Test + public void testAllFilesPresentInP_5() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/neg/2.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-minus-expression") + @TestDataPath("$PROJECT_ROOT") + public class Unary_minus_expression { + @Test + public void testAllFilesPresentInUnary_minus_expression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-minus-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-minus-expression/p-3") + @TestDataPath("$PROJECT_ROOT") + public class P_3 { + @Test + public void testAllFilesPresentInP_3() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-minus-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-minus-expression/p-3/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-minus-expression/p-3/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-minus-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-plus-expression") + @TestDataPath("$PROJECT_ROOT") + public class Unary_plus_expression { + @Test + public void testAllFilesPresentInUnary_plus_expression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-plus-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-plus-expression/p-3") + @TestDataPath("$PROJECT_ROOT") + public class P_3 { + @Test + public void testAllFilesPresentInP_3() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-plus-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-plus-expression/p-3/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-plus-expression/p-3/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-plus-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/range-expression") + @TestDataPath("$PROJECT_ROOT") + public class Range_expression { + @Test + public void testAllFilesPresentInRange_expression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/range-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/range-expression/p-4") + @TestDataPath("$PROJECT_ROOT") + public class P_4 { + @Test + public void testAllFilesPresentInP_4() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/range-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/range-expression/p-4/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/range-expression/p-4/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/range-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression") + @TestDataPath("$PROJECT_ROOT") + public class Try_expression { + @Test + public void testAllFilesPresentInTry_expression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/neg/1.1.kt"); + } + + @Test + @TestMetadata("3.1.kt") + public void test3_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/neg/3.1.kt"); + } + + @Test + @TestMetadata("4.1.kt") + public void test4_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/neg/4.1.kt"); + } + + @Test + @TestMetadata("5.1.kt") + public void test5_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/neg/5.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/pos/1.1.kt"); + } + + @Test + @TestMetadata("3.1.kt") + public void test3_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/pos/3.1.kt"); + } + + @Test + @TestMetadata("3.2.kt") + public void test3_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/pos/3.2.kt"); + } + + @Test + @TestMetadata("4.1.kt") + public void test4_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/pos/4.1.kt"); + } + + @Test + @TestMetadata("4.2.kt") + public void test4_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/pos/4.2.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-2") + @TestDataPath("$PROJECT_ROOT") + public class P_2 { + @Test + public void testAllFilesPresentInP_2() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-2/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-2/pos/2.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-5") + @TestDataPath("$PROJECT_ROOT") + public class P_5 { + @Test + public void testAllFilesPresentInP_5() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-5/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-5/pos/1.1.kt"); + } + + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-5/pos/2.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-8") + @TestDataPath("$PROJECT_ROOT") + public class P_8 { + @Test + public void testAllFilesPresentInP_8() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-8"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-8/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-8/neg/1.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-8/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-8/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-8/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-8/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions") + @TestDataPath("$PROJECT_ROOT") + public class Type_checking_and_containment_checking_expressions { + @Test + public void testAllFilesPresentInType_checking_and_containment_checking_expressions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression") + @TestDataPath("$PROJECT_ROOT") + public class Containment_checking_expression { + @Test + public void testAllFilesPresentInContainment_checking_expression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-5") + @TestDataPath("$PROJECT_ROOT") + public class P_5 { + @Test + public void testAllFilesPresentInP_5() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-5/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-5/pos/2.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression") + @TestDataPath("$PROJECT_ROOT") + public class Type_checking_expression { + @Test + public void testAllFilesPresentInType_checking_expression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-4") + @TestDataPath("$PROJECT_ROOT") + public class P_4 { + @Test + public void testAllFilesPresentInP_4() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-4/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-4/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression") + @TestDataPath("$PROJECT_ROOT") + public class When_expression { + @Test + public void testAllFilesPresentInWhen_expression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions") + @TestDataPath("$PROJECT_ROOT") + public class Exhaustive_when_expressions { + @Test + public void testAllFilesPresentInExhaustive_when_expressions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2") + @TestDataPath("$PROJECT_ROOT") + public class P_2 { + @Test + public void testAllFilesPresentInP_2() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("11.1.kt") + public void test11_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/neg/11.1.kt"); + } + + @Test + @TestMetadata("11.2.kt") + public void test11_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/neg/11.2.kt"); + } + + @Test + @TestMetadata("11.3.kt") + public void test11_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/neg/11.3.kt"); + } + + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/neg/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/neg/1.2.kt"); + } + + @Test + @TestMetadata("3.1.kt") + public void test3_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/neg/3.1.kt"); + } + + @Test + @TestMetadata("9.1.kt") + public void test9_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/neg/9.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("10.1.kt") + public void test10_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/pos/10.1.kt"); + } + + @Test + @TestMetadata("11.1.kt") + public void test11_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/pos/11.1.kt"); + } + + @Test + @TestMetadata("11.2.kt") + public void test11_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/pos/11.2.kt"); + } + + @Test + @TestMetadata("11.3.kt") + public void test11_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/pos/11.3.kt"); + } + + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/pos/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/pos/1.2.kt"); + } + + @Test + @TestMetadata("1.3.kt") + public void test1_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/pos/1.3.kt"); + } + + @Test + @TestMetadata("3.1.kt") + public void test3_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/pos/3.1.kt"); + } + + @Test + @TestMetadata("7.1.kt") + public void test7_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/pos/7.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-1/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("3.1.kt") + public void test3_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-1/pos/3.1.kt"); + } + + @Test + @TestMetadata("3.2.kt") + public void test3_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-1/pos/3.2.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2") + @TestDataPath("$PROJECT_ROOT") + public class P_2 { + @Test + public void testAllFilesPresentInP_2() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2/neg/2.1.kt"); + } + + @Test + @TestMetadata("2.2.kt") + public void test2_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2/neg/2.2.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2/pos/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2/pos/1.2.kt"); + } + + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2/pos/2.1.kt"); + } + + @Test + @TestMetadata("2.2.kt") + public void test2_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2/pos/2.2.kt"); + } + + @Test + @TestMetadata("2.3.kt") + public void test2_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2/pos/2.3.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-3") + @TestDataPath("$PROJECT_ROOT") + public class P_3 { + @Test + public void testAllFilesPresentInP_3() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-3/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-3/neg/2.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-4") + @TestDataPath("$PROJECT_ROOT") + public class P_4 { + @Test + public void testAllFilesPresentInP_4() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-4/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-4/neg/1.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-4/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-4/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-5") + @TestDataPath("$PROJECT_ROOT") + public class P_5 { + @Test + public void testAllFilesPresentInP_5() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-5/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-5/neg/1.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-5/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-5/pos/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-5/pos/1.2.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6") + @TestDataPath("$PROJECT_ROOT") + public class P_6 { + @Test + public void testAllFilesPresentInP_6() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/neg/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/neg/1.2.kt"); + } + + @Test + @TestMetadata("3.1.kt") + public void test3_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/neg/3.1.kt"); + } + + @Test + @TestMetadata("3.2.kt") + public void test3_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/neg/3.2.kt"); + } + + @Test + @TestMetadata("5.1.kt") + public void test5_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/neg/5.1.kt"); + } + + @Test + @TestMetadata("5.2.kt") + public void test5_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/neg/5.2.kt"); + } + + @Test + @TestMetadata("7.1.kt") + public void test7_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/neg/7.1.kt"); + } + + @Test + @TestMetadata("7.2.kt") + public void test7_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/neg/7.2.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/pos/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/pos/1.2.kt"); + } + + @Test + @TestMetadata("1.3.kt") + public void test1_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/pos/1.3.kt"); + } + + @Test + @TestMetadata("1.4.kt") + public void test1_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/pos/1.4.kt"); + } + + @Test + @TestMetadata("3.1.kt") + public void test3_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/pos/3.1.kt"); + } + + @Test + @TestMetadata("3.2.kt") + public void test3_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/pos/3.2.kt"); + } + + @Test + @TestMetadata("5.1.kt") + public void test5_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/pos/5.1.kt"); + } + + @Test + @TestMetadata("5.2.kt") + public void test5_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/pos/5.2.kt"); + } + + @Test + @TestMetadata("6.1.kt") + public void test6_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/pos/6.1.kt"); + } + + @Test + @TestMetadata("7.1.kt") + public void test7_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/pos/7.1.kt"); + } + + @Test + @TestMetadata("7.2.kt") + public void test7_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/pos/7.2.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution") + @TestDataPath("$PROJECT_ROOT") + public class Overload_resolution { + @Test + public void testAllFilesPresentInOverload_resolution() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "c-level-partition", "determining-function-applicability-for-a-specific-call/rationale"); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs") + @TestDataPath("$PROJECT_ROOT") + public class Building_the_overload_candidate_set_ocs { + @Test + public void testAllFilesPresentInBuilding_the_overload_candidate_set_ocs() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver") + @TestDataPath("$PROJECT_ROOT") + public class Call_with_an_explicit_receiver { + @Test + public void testAllFilesPresentInCall_with_an_explicit_receiver() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/call-with-an-explicit-type-receiver") + @TestDataPath("$PROJECT_ROOT") + public class Call_with_an_explicit_type_receiver { + @Test + public void testAllFilesPresentInCall_with_an_explicit_type_receiver() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/call-with-an-explicit-type-receiver"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/call-with-an-explicit-type-receiver/p-3") + @TestDataPath("$PROJECT_ROOT") + public class P_3 { + @Test + public void testAllFilesPresentInP_3() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/call-with-an-explicit-type-receiver/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/call-with-an-explicit-type-receiver/p-3/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/call-with-an-explicit-type-receiver/p-3/pos/2.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/call-with-an-explicit-type-receiver/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6") + @TestDataPath("$PROJECT_ROOT") + public class P_6 { + @Test + public void testAllFilesPresentInP_6() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/1.2.kt"); + } + + @Test + @TestMetadata("1.3.kt") + public void test1_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/1.3.kt"); + } + + @Test + @TestMetadata("1.4.kt") + public void test1_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/1.4.kt"); + } + + @Test + @TestMetadata("1.5.kt") + public void test1_5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/1.5.kt"); + } + + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/2.1.kt"); + } + + @Test + @TestMetadata("2.2.kt") + public void test2_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/2.2.kt"); + } + + @Test + @TestMetadata("2.3.kt") + public void test2_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/2.3.kt"); + } + + @Test + @TestMetadata("2.4.kt") + public void test2_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/2.4.kt"); + } + + @Test + @TestMetadata("3.1.kt") + public void test3_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/3.1.kt"); + } + + @Test + @TestMetadata("3.2.kt") + public void test3_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/3.2.kt"); + } + + @Test + @TestMetadata("4.1.kt") + public void test4_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/4.1.kt"); + } + + @Test + @TestMetadata("4.2.kt") + public void test4_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/4.2.kt"); + } + + @Test + @TestMetadata("5.1.kt") + public void test5_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/5.1.kt"); + } + + @Test + @TestMetadata("5.2.kt") + public void test5_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/5.2.kt"); + } + + @Test + @TestMetadata("6.1.kt") + public void test6_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos/6.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters") + @TestDataPath("$PROJECT_ROOT") + public class Call_with_named_parameters { + @Test + public void testAllFilesPresentInCall_with_named_parameters() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1/pos/2.1.kt"); + } + + @Test + @TestMetadata("2.10.kt") + public void test2_10() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1/pos/2.10.kt"); + } + + @Test + @TestMetadata("2.11.kt") + public void test2_11() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1/pos/2.11.kt"); + } + + @Test + @TestMetadata("2.12.kt") + public void test2_12() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1/pos/2.12.kt"); + } + + @Test + @TestMetadata("2.13.kt") + public void test2_13() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1/pos/2.13.kt"); + } + + @Test + @TestMetadata("2.14.kt") + public void test2_14() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1/pos/2.14.kt"); + } + + @Test + @TestMetadata("2.15.kt") + public void test2_15() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1/pos/2.15.kt"); + } + + @Test + @TestMetadata("2.16.kt") + public void test2_16() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1/pos/2.16.kt"); + } + + @Test + @TestMetadata("2.2.kt") + public void test2_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1/pos/2.2.kt"); + } + + @Test + @TestMetadata("2.3.kt") + public void test2_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1/pos/2.3.kt"); + } + + @Test + @TestMetadata("2.4.kt") + public void test2_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1/pos/2.4.kt"); + } + + @Test + @TestMetadata("2.5.kt") + public void test2_5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1/pos/2.5.kt"); + } + + @Test + @TestMetadata("2.6.kt") + public void test2_6() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1/pos/2.6.kt"); + } + + @Test + @TestMetadata("2.7.kt") + public void test2_7() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1/pos/2.7.kt"); + } + + @Test + @TestMetadata("2.8.kt") + public void test2_8() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1/pos/2.8.kt"); + } + + @Test + @TestMetadata("2.9.kt") + public void test2_9() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1/pos/2.9.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-5") + @TestDataPath("$PROJECT_ROOT") + public class P_5 { + @Test + public void testAllFilesPresentInP_5() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-5/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-specified-type-parameters") + @TestDataPath("$PROJECT_ROOT") + public class Call_with_specified_type_parameters { + @Test + public void testAllFilesPresentInCall_with_specified_type_parameters() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-specified-type-parameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-specified-type-parameters/p-2") + @TestDataPath("$PROJECT_ROOT") + public class P_2 { + @Test + public void testAllFilesPresentInP_2() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-specified-type-parameters/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-specified-type-parameters/p-2/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-specified-type-parameters/p-2/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-specified-type-parameters/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions") + @TestDataPath("$PROJECT_ROOT") + public class Call_with_trailing_lambda_expressions { + @Test + public void testAllFilesPresentInCall_with_trailing_lambda_expressions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.1.kt"); + } + + @Test + @TestMetadata("2.10.kt") + public void test2_10() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.10.kt"); + } + + @Test + @TestMetadata("2.11.kt") + public void test2_11() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.11.kt"); + } + + @Test + @TestMetadata("2.12.kt") + public void test2_12() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.12.kt"); + } + + @Test + @TestMetadata("2.13.kt") + public void test2_13() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.13.kt"); + } + + @Test + @TestMetadata("2.14.kt") + public void test2_14() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.14.kt"); + } + + @Test + @TestMetadata("2.15.kt") + public void test2_15() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.15.kt"); + } + + @Test + @TestMetadata("2.16.kt") + public void test2_16() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.16.kt"); + } + + @Test + @TestMetadata("2.17.kt") + public void test2_17() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.17.kt"); + } + + @Test + @TestMetadata("2.18.kt") + public void test2_18() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.18.kt"); + } + + @Test + @TestMetadata("2.19.kt") + public void test2_19() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.19.kt"); + } + + @Test + @TestMetadata("2.2.kt") + public void test2_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.2.kt"); + } + + @Test + @TestMetadata("2.20.kt") + public void test2_20() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.20.kt"); + } + + @Test + @TestMetadata("2.21.kt") + public void test2_21() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.21.kt"); + } + + @Test + @TestMetadata("2.3.kt") + public void test2_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.3.kt"); + } + + @Test + @TestMetadata("2.4.kt") + public void test2_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.4.kt"); + } + + @Test + @TestMetadata("2.5.kt") + public void test2_5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.5.kt"); + } + + @Test + @TestMetadata("2.6.kt") + public void test2_6() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.6.kt"); + } + + @Test + @TestMetadata("2.7.kt") + public void test2_7() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.7.kt"); + } + + @Test + @TestMetadata("2.8.kt") + public void test2_8() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.8.kt"); + } + + @Test + @TestMetadata("2.9.kt") + public void test2_9() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.9.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver") + @TestDataPath("$PROJECT_ROOT") + public class Call_without_an_explicit_receiver { + @Test + public void testAllFilesPresentInCall_without_an_explicit_receiver() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5") + @TestDataPath("$PROJECT_ROOT") + public class P_5 { + @Test + public void testAllFilesPresentInP_5() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("2.3.kt") + public void test2_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/neg/2.3.kt"); + } + + @Test + @TestMetadata("2.4.kt") + public void test2_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/neg/2.4.kt"); + } + + @Test + @TestMetadata("2.5.kt") + public void test2_5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/neg/2.5.kt"); + } + + @Test + @TestMetadata("4.1.kt") + public void test4_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/neg/4.1.kt"); + } + + @Test + @TestMetadata("4.2.kt") + public void test4_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/neg/4.2.kt"); + } + + @Test + @TestMetadata("6.1.kt") + public void test6_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/neg/6.1.kt"); + } + + @Test + @TestMetadata("6.4.kt") + public void test6_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/neg/6.4.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/pos/2.1.kt"); + } + + @Test + @TestMetadata("2.2.kt") + public void test2_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/pos/2.2.kt"); + } + + @Test + @TestMetadata("2.3.kt") + public void test2_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/pos/2.3.kt"); + } + + @Test + @TestMetadata("2.4.kt") + public void test2_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/pos/2.4.kt"); + } + + @Test + @TestMetadata("2.5.kt") + public void test2_5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/pos/2.5.kt"); + } + + @Test + @TestMetadata("4.1.kt") + public void test4_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/pos/4.1.kt"); + } + + @Test + @TestMetadata("4.2.kt") + public void test4_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/pos/4.2.kt"); + } + + @Test + @TestMetadata("4.3.kt") + public void test4_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/pos/4.3.kt"); + } + + @Test + @TestMetadata("4.4.kt") + public void test4_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/pos/4.4.kt"); + } + + @Test + @TestMetadata("4.5.kt") + public void test4_5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/pos/4.5.kt"); + } + + @Test + @TestMetadata("4.6.kt") + public void test4_6() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/pos/4.6.kt"); + } + + @Test + @TestMetadata("5.1.kt") + public void test5_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/pos/5.1.kt"); + } + + @Test + @TestMetadata("6.1.kt") + public void test6_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/pos/6.1.kt"); + } + + @Test + @TestMetadata("6.2.kt") + public void test6_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/pos/6.2.kt"); + } + + @Test + @TestMetadata("6.3.kt") + public void test6_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/pos/6.3.kt"); + } + + @Test + @TestMetadata("7.1.kt") + public void test7_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/pos/7.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call") + @TestDataPath("$PROJECT_ROOT") + public class Infix_function_call { + @Test + public void testAllFilesPresentInInfix_function_call() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2") + @TestDataPath("$PROJECT_ROOT") + public class P_2 { + @Test + public void testAllFilesPresentInP_2() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/neg/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/neg/1.2.kt"); + } + + @Test + @TestMetadata("1.3.kt") + public void test1_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/neg/1.3.kt"); + } + + @Test + @TestMetadata("1.4.kt") + public void test1_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/neg/1.4.kt"); + } + + @Test + @TestMetadata("4.5.kt") + public void test4_5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/neg/4.5.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("4.1.kt") + public void test4_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/pos/4.1.kt"); + } + + @Test + @TestMetadata("4.2.kt") + public void test4_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/pos/4.2.kt"); + } + + @Test + @TestMetadata("4.3.kt") + public void test4_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/pos/4.3.kt"); + } + + @Test + @TestMetadata("4.4.kt") + public void test4_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/pos/4.4.kt"); + } + + @Test + @TestMetadata("4.5.kt") + public void test4_5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/pos/4.5.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call") + @TestDataPath("$PROJECT_ROOT") + public class Operator_call { + @Test + public void testAllFilesPresentInOperator_call() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.1.kt"); + } + + @Test + @TestMetadata("2.2.kt") + public void test2_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.2.kt"); + } + + @Test + @TestMetadata("2.4.kt") + public void test2_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.4.kt"); + } + + @Test + @TestMetadata("2.5.kt") + public void test2_5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.5.kt"); + } + + @Test + @TestMetadata("2.6.kt") + public void test2_6() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.6.kt"); + } + + @Test + @TestMetadata("2.7.kt") + public void test2_7() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.7.kt"); + } + + @Test + @TestMetadata("2.8.kt") + public void test2_8() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.8.kt"); + } + + @Test + @TestMetadata("2.9.kt") + public void test2_9() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.9.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.1.kt"); + } + + @Test + @TestMetadata("2.2.kt") + public void test2_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.2.kt"); + } + + @Test + @TestMetadata("2.3.kt") + public void test2_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos/2.3.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2") + @TestDataPath("$PROJECT_ROOT") + public class P_2 { + @Test + public void testAllFilesPresentInP_2() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("3.1.kt") + public void test3_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos/3.1.kt"); + } + + @Test + @TestMetadata("3.2.kt") + public void test3_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos/3.2.kt"); + } + + @Test + @TestMetadata("3.3.kt") + public void test3_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos/3.3.kt"); + } + + @Test + @TestMetadata("3.4.kt") + public void test3_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos/3.4.kt"); + } + + @Test + @TestMetadata("3.5.kt") + public void test3_5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos/3.5.kt"); + } + + @Test + @TestMetadata("3.6.kt") + public void test3_6() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos/3.6.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4") + @TestDataPath("$PROJECT_ROOT") + public class P_4 { + @Test + public void testAllFilesPresentInP_4() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/neg/1.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/callables-and-invoke-convention") + @TestDataPath("$PROJECT_ROOT") + public class Callables_and_invoke_convention { + @Test + public void testAllFilesPresentInCallables_and_invoke_convention() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/callables-and-invoke-convention"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/callables-and-invoke-convention/p-2") + @TestDataPath("$PROJECT_ROOT") + public class P_2 { + @Test + public void testAllFilesPresentInP_2() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/callables-and-invoke-convention/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/callables-and-invoke-convention/p-2/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("10.1.kt") + public void test10_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/callables-and-invoke-convention/p-2/pos/10.1.kt"); + } + + @Test + @TestMetadata("8.1.kt") + public void test8_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/callables-and-invoke-convention/p-2/pos/8.1.kt"); + } + + @Test + @TestMetadata("9.1.kt") + public void test9_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/callables-and-invoke-convention/p-2/pos/9.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/callables-and-invoke-convention/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set") + @TestDataPath("$PROJECT_ROOT") + public class Choosing_the_most_specific_candidate_from_the_overload_candidate_set { + @Test + public void testAllFilesPresentInChoosing_the_most_specific_candidate_from_the_overload_candidate_set() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection") + @TestDataPath("$PROJECT_ROOT") + public class Algorithm_of_msc_selection { + @Test + public void testAllFilesPresentInAlgorithm_of_msc_selection() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-11") + @TestDataPath("$PROJECT_ROOT") + public class P_11 { + @Test + public void testAllFilesPresentInP_11() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-11"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-11/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-11/pos/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-11/pos/1.2.kt"); + } + + @Test + @TestMetadata("4.1.kt") + public void test4_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-11/pos/4.1.kt"); + } + + @Test + @TestMetadata("4.2.kt") + public void test4_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-11/pos/4.2.kt"); + } + + @Test + @TestMetadata("4.3.kt") + public void test4_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-11/pos/4.3.kt"); + } + + @Test + @TestMetadata("4.4.kt") + public void test4_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-11/pos/4.4.kt"); + } + + @Test + @TestMetadata("4.5.kt") + public void test4_5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-11/pos/4.5.kt"); + } + + @Test + @TestMetadata("5.1.kt") + public void test5_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-11/pos/5.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-11/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-12") + @TestDataPath("$PROJECT_ROOT") + public class P_12 { + @Test + public void testAllFilesPresentInP_12() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-12"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-12/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-12/pos/2.1.kt"); + } + + @Test + @TestMetadata("2.2.kt") + public void test2_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-12/pos/2.2.kt"); + } + + @Test + @TestMetadata("2.3.kt") + public void test2_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-12/pos/2.3.kt"); + } + + @Test + @TestMetadata("2.4.kt") + public void test2_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-12/pos/2.4.kt"); + } + + @Test + @TestMetadata("2.5.kt") + public void test2_5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-12/pos/2.5.kt"); + } + + @Test + @TestMetadata("2.6.kt") + public void test2_6() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-12/pos/2.6.kt"); + } + + @Test + @TestMetadata("2.7.kt") + public void test2_7() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-12/pos/2.7.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-12/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-14") + @TestDataPath("$PROJECT_ROOT") + public class P_14 { + @Test + public void testAllFilesPresentInP_14() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-14"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-14/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-14/neg/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-14/neg/1.2.kt"); + } + + @Test + @TestMetadata("1.3.kt") + public void test1_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-14/neg/1.3.kt"); + } + + @Test + @TestMetadata("1.4.kt") + public void test1_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-14/neg/1.4.kt"); + } + + @Test + @TestMetadata("1.5.kt") + public void test1_5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-14/neg/1.5.kt"); + } + + @Test + @TestMetadata("1.6.kt") + public void test1_6() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-14/neg/1.6.kt"); + } + + @Test + @TestMetadata("1.7.kt") + public void test1_7() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-14/neg/1.7.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-14/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-17") + @TestDataPath("$PROJECT_ROOT") + public class P_17 { + @Test + public void testAllFilesPresentInP_17() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-17"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-17/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-17/neg/2.1.kt"); + } + + @Test + @TestMetadata("2.2.kt") + public void test2_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-17/neg/2.2.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-17/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-3") + @TestDataPath("$PROJECT_ROOT") + public class P_3 { + @Test + public void testAllFilesPresentInP_3() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-3/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-3/pos/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-3/pos/1.2.kt"); + } + + @Test + @TestMetadata("1.3.kt") + public void test1_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-3/pos/1.3.kt"); + } + + @Test + @TestMetadata("1.4.kt") + public void test1_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-3/pos/1.4.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-9") + @TestDataPath("$PROJECT_ROOT") + public class P_9 { + @Test + public void testAllFilesPresentInP_9() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-9"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-9/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-9/neg/2.1.kt"); + } + + @Test + @TestMetadata("2.2.kt") + public void test2_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-9/neg/2.2.kt"); + } + + @Test + @TestMetadata("2.3.kt") + public void test2_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-9/neg/2.3.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-9/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-9/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-9/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-9/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1") + @TestDataPath("$PROJECT_ROOT") + public class Rationale_1 { + @Test + public void testAllFilesPresentInRationale_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-2") + @TestDataPath("$PROJECT_ROOT") + public class P_2 { + @Test + public void testAllFilesPresentInP_2() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-2/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-2/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-3") + @TestDataPath("$PROJECT_ROOT") + public class P_3 { + @Test + public void testAllFilesPresentInP_3() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-3/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-3/neg/1.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call") + @TestDataPath("$PROJECT_ROOT") + public class Determining_function_applicability_for_a_specific_call { + @Test + public void testAllFilesPresentInDetermining_function_applicability_for_a_specific_call() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "rationale"); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description") + @TestDataPath("$PROJECT_ROOT") + public class Description { + @Test + public void testAllFilesPresentInDescription() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description/p-2") + @TestDataPath("$PROJECT_ROOT") + public class P_2 { + @Test + public void testAllFilesPresentInP_2() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description/p-2/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description/p-2/neg/2.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/receivers") + @TestDataPath("$PROJECT_ROOT") + public class Receivers { + @Test + public void testAllFilesPresentInReceivers() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/receivers"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/receivers/p-5") + @TestDataPath("$PROJECT_ROOT") + public class P_5 { + @Test + public void testAllFilesPresentInP_5() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/receivers/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/receivers/p-5/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/receivers/p-5/pos/2.1.kt"); + } + + @Test + @TestMetadata("3.1.kt") + public void test3_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/receivers/p-5/pos/3.1.kt"); + } + + @Test + @TestMetadata("5.1.kt") + public void test5_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/receivers/p-5/pos/5.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/receivers/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references") + @TestDataPath("$PROJECT_ROOT") + public class Resolving_callable_references { + @Test + public void testAllFilesPresentInResolving_callable_references() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls") + @TestDataPath("$PROJECT_ROOT") + public class Bidirectional_resolution_for_callable_calls { + @Test + public void testAllFilesPresentInBidirectional_resolution_for_callable_calls() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-1/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-1/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-3") + @TestDataPath("$PROJECT_ROOT") + public class P_3 { + @Test + public void testAllFilesPresentInP_3() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-3/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-3/neg/1.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-3/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-3/pos/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-3/pos/1.2.kt"); + } + + @Test + @TestMetadata("1.3.kt") + public void test1_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-3/pos/1.3.kt"); + } + + @Test + @TestMetadata("1.4.kt") + public void test1_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-3/pos/1.4.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/p-2") + @TestDataPath("$PROJECT_ROOT") + public class P_2 { + @Test + public void testAllFilesPresentInP_2() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/p-2/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/p-2/pos/2.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call") + @TestDataPath("$PROJECT_ROOT") + public class Resolving_callable_references_not_used_as_arguments_to_a_call { + @Test + public void testAllFilesPresentInResolving_callable_references_not_used_as_arguments_to_a_call() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1/neg/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1/neg/1.2.kt"); + } + + @Test + @TestMetadata("1.3.kt") + public void test1_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1/neg/1.3.kt"); + } + + @Test + @TestMetadata("1.4.kt") + public void test1_4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1/neg/1.4.kt"); + } + + @Test + @TestMetadata("1.5.kt") + public void test1_5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1/neg/1.5.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1/pos/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1/pos/1.2.kt"); + } + + @Test + @TestMetadata("1.3.kt") + public void test1_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1/pos/1.3.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements") + @TestDataPath("$PROJECT_ROOT") + public class Statements { + @Test + public void testAllFilesPresentInStatements() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "assignments/simple-assignments"); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/assignments") + @TestDataPath("$PROJECT_ROOT") + public class Assignments { + @Test + public void testAllFilesPresentInAssignments() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "simple-assignments"); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments") + @TestDataPath("$PROJECT_ROOT") + public class Operator_assignments { + @Test + public void testAllFilesPresentInOperator_assignments() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2") + @TestDataPath("$PROJECT_ROOT") + public class P_2 { + @Test + public void testAllFilesPresentInP_2() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2/neg/1.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-1/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-1/neg/2.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-2") + @TestDataPath("$PROJECT_ROOT") + public class P_2 { + @Test + public void testAllFilesPresentInP_2() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-2/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-2/neg/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-2/neg/1.2.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements") + @TestDataPath("$PROJECT_ROOT") + public class Loop_statements { + @Test + public void testAllFilesPresentInLoop_statements() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement") + @TestDataPath("$PROJECT_ROOT") + public class Do_while_loop_statement { + @Test + public void testAllFilesPresentInDo_while_loop_statement() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-1/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-1/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-3") + @TestDataPath("$PROJECT_ROOT") + public class P_3 { + @Test + public void testAllFilesPresentInP_3() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-3/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-3/neg/1.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement") + @TestDataPath("$PROJECT_ROOT") + public class While_loop_statement { + @Test + public void testAllFilesPresentInWhile_loop_statement() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-1/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-1/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-3") + @TestDataPath("$PROJECT_ROOT") + public class P_3 { + @Test + public void testAllFilesPresentInP_3() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-3/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-3/neg/1.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-inference") + @TestDataPath("$PROJECT_ROOT") + public class Type_inference { + @Test + public void testAllFilesPresentInType_inference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "local-type-inference", "smart-casts/smart-cast-types"); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts") + @TestDataPath("$PROJECT_ROOT") + public class Smart_casts { + @Test + public void testAllFilesPresentInSmart_casts() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "smart-cast-types"); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability") + @TestDataPath("$PROJECT_ROOT") + public class Smart_cast_sink_stability { + @Test + public void testAllFilesPresentInSmart_cast_sink_stability() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability/p-5") + @TestDataPath("$PROJECT_ROOT") + public class P_5 { + @Test + public void testAllFilesPresentInP_5() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability/p-5/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability/p-5/neg/1.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability/p-5/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability/p-5/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system") + @TestDataPath("$PROJECT_ROOT") + public class Type_system { + @Test + public void testAllFilesPresentInType_system() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "subtyping/subtyping-for-nullable-types", "type-kinds/type-parameters"); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1") + @TestDataPath("$PROJECT_ROOT") + public class Introduction_1 { + @Test + public void testAllFilesPresentInIntroduction_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-6") + @TestDataPath("$PROJECT_ROOT") + public class P_6 { + @Test + public void testAllFilesPresentInP_6() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-6"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-6/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-6/neg/2.1.kt"); + } + + @Test + @TestMetadata("2.2.kt") + public void test2_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-6/neg/2.2.kt"); + } + + @Test + @TestMetadata("2.3.kt") + public void test2_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-6/neg/2.3.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-6/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-8") + @TestDataPath("$PROJECT_ROOT") + public class P_8 { + @Test + public void testAllFilesPresentInP_8() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-8"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-8/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-8/pos/1.1.kt"); + } + + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-8/pos/2.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-8/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping") + @TestDataPath("$PROJECT_ROOT") + public class Subtyping { + @Test + public void testAllFilesPresentInSubtyping() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "subtyping-for-nullable-types"); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types") + @TestDataPath("$PROJECT_ROOT") + public class Subtyping_for_intersection_types { + @Test + public void testAllFilesPresentInSubtyping_for_intersection_types() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types/p-1/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types/p-1/pos/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types/p-1/pos/1.2.kt"); + } + + @Test + @TestMetadata("1.3.kt") + public void test1_3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types/p-1/pos/1.3.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-rules") + @TestDataPath("$PROJECT_ROOT") + public class Subtyping_rules { + @Test + public void testAllFilesPresentInSubtyping_rules() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-rules"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-rules/p-2") + @TestDataPath("$PROJECT_ROOT") + public class P_2 { + @Test + public void testAllFilesPresentInP_2() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-rules/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-rules/p-2/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-rules/p-2/pos/1.1.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-rules/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes") + @TestDataPath("$PROJECT_ROOT") + public class Type_contexts_and_scopes { + @Test + public void testAllFilesPresentInType_contexts_and_scopes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts") + @TestDataPath("$PROJECT_ROOT") + public class Inner_and_nested_type_contexts { + @Test + public void testAllFilesPresentInInner_and_nested_type_contexts() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1/neg/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1/neg/1.2.kt"); + } + + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1/neg/2.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1/pos/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1/pos/1.2.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds") + @TestDataPath("$PROJECT_ROOT") + public class Type_kinds { + @Test + public void testAllFilesPresentInType_kinds() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true, "type-parameters"); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types") + @TestDataPath("$PROJECT_ROOT") + public class Built_in_types { + @Test + public void testAllFilesPresentInBuilt_in_types() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any") + @TestDataPath("$PROJECT_ROOT") + public class Kotlin_any { + @Test + public void testAllFilesPresentInKotlin_any() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any/p-1/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any/p-1/pos/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any/p-1/pos/1.2.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing") + @TestDataPath("$PROJECT_ROOT") + public class Kotlin_nothing { + @Test + public void testAllFilesPresentInKotlin_nothing() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1") + @TestDataPath("$PROJECT_ROOT") + public class P_1 { + @Test + public void testAllFilesPresentInP_1() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("2.1.kt") + public void test2_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/neg/2.1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.1.kt") + public void test1_1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/pos/1.1.kt"); + } + + @Test + @TestMetadata("1.2.kt") + public void test1_2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/pos/1.2.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked") + @TestDataPath("$PROJECT_ROOT") + public class NotLinked { + @Test + public void testAllFilesPresentInNotLinked() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/annotations") + @TestDataPath("$PROJECT_ROOT") + public class Annotations { + @Test + public void testAllFilesPresentInAnnotations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/annotations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/annotations/annotation-classes") + @TestDataPath("$PROJECT_ROOT") + public class Annotation_classes { + @Test + public void testAllFilesPresentInAnnotation_classes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/annotations/annotation-classes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/annotations/annotation-classes/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.kt") + public void test1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/annotations/annotation-classes/neg/1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/annotations/annotation-classes/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations") + @TestDataPath("$PROJECT_ROOT") + public class Type_annotations { + @Test + public void testAllFilesPresentInType_annotations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.kt") + public void test1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg/1.kt"); + } + + @Test + @TestMetadata("10.kt") + public void test10() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg/10.kt"); + } + + @Test + @TestMetadata("11.kt") + public void test11() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg/11.kt"); + } + + @Test + @TestMetadata("2.kt") + public void test2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg/2.kt"); + } + + @Test + @TestMetadata("3.kt") + public void test3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg/3.kt"); + } + + @Test + @TestMetadata("4.kt") + public void test4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg/4.kt"); + } + + @Test + @TestMetadata("5.kt") + public void test5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg/5.kt"); + } + + @Test + @TestMetadata("6.kt") + public void test6() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg/6.kt"); + } + + @Test + @TestMetadata("7.kt") + public void test7() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg/7.kt"); + } + + @Test + @TestMetadata("8.kt") + public void test8() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg/8.kt"); + } + + @Test + @TestMetadata("9.kt") + public void test9() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg/9.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/coercion-to-unit") + @TestDataPath("$PROJECT_ROOT") + public class Coercion_to_unit { + @Test + public void testAllFilesPresentInCoercion_to_unit() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/coercion-to-unit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/coercion-to-unit/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.kt") + public void test1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/coercion-to-unit/neg/1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/coercion-to-unit/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts") + @TestDataPath("$PROJECT_ROOT") + public class Contracts { + @Test + public void testAllFilesPresentInContracts() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis") + @TestDataPath("$PROJECT_ROOT") + public class Analysis { + @Test + public void testAllFilesPresentInAnalysis() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common") + @TestDataPath("$PROJECT_ROOT") + public class Common { + @Test + public void testAllFilesPresentInCommon() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.kt") + public void test1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common/neg/1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.kt") + public void test1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common/pos/1.kt"); + } + + @Test + @TestMetadata("2.kt") + public void test2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common/pos/2.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow") + @TestDataPath("$PROJECT_ROOT") + public class ControlFlow { + @Test + public void testAllFilesPresentInControlFlow() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization") + @TestDataPath("$PROJECT_ROOT") + public class Initialization { + @Test + public void testAllFilesPresentInInitialization() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.kt") + public void test1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/neg/1.kt"); + } + + @Test + @TestMetadata("2.kt") + public void test2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/neg/2.kt"); + } + + @Test + @TestMetadata("3.kt") + public void test3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/neg/3.kt"); + } + + @Test + @TestMetadata("4.kt") + public void test4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/neg/4.kt"); + } + + @Test + @TestMetadata("5.kt") + public void test5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/neg/5.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.kt") + public void test1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/pos/1.kt"); + } + + @Test + @TestMetadata("2.kt") + public void test2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/pos/2.kt"); + } + + @Test + @TestMetadata("3.kt") + public void test3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/pos/3.kt"); + } + + @Test + @TestMetadata("4.kt") + public void test4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/pos/4.kt"); + } + + @Test + @TestMetadata("5.kt") + public void test5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/pos/5.kt"); + } + + @Test + @TestMetadata("6.kt") + public void test6() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/pos/6.kt"); + } + + @Test + @TestMetadata("7.kt") + public void test7() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/pos/7.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode") + @TestDataPath("$PROJECT_ROOT") + public class UnreachableCode { + @Test + public void testAllFilesPresentInUnreachableCode() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.kt") + public void test1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode/neg/1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.kt") + public void test1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode/pos/1.kt"); + } + + @Test + @TestMetadata("2.kt") + public void test2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode/pos/2.kt"); + } + + @Test + @TestMetadata("3.kt") + public void test3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode/pos/3.kt"); + } + + @Test + @TestMetadata("4.kt") + public void test4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode/pos/4.kt"); + } + + @Test + @TestMetadata("5.kt") + public void test5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode/pos/5.kt"); + } + + @Test + @TestMetadata("6.kt") + public void test6() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode/pos/6.kt"); + } + + @Test + @TestMetadata("7.kt") + public void test7() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode/pos/7.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts") + @TestDataPath("$PROJECT_ROOT") + public class Smartcasts { + @Test + public void testAllFilesPresentInSmartcasts() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.kt") + public void test1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/1.kt"); + } + + @Test + @TestMetadata("10.kt") + public void test10() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/10.kt"); + } + + @Test + @TestMetadata("11.kt") + public void test11() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/11.kt"); + } + + @Test + @TestMetadata("12.kt") + public void test12() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/12.kt"); + } + + @Test + @TestMetadata("13.kt") + public void test13() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/13.kt"); + } + + @Test + @TestMetadata("14.kt") + public void test14() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/14.kt"); + } + + @Test + @TestMetadata("15.kt") + public void test15() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/15.kt"); + } + + @Test + @TestMetadata("2.kt") + public void test2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/2.kt"); + } + + @Test + @TestMetadata("3.kt") + public void test3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/3.kt"); + } + + @Test + @TestMetadata("4.kt") + public void test4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/4.kt"); + } + + @Test + @TestMetadata("5.kt") + public void test5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/5.kt"); + } + + @Test + @TestMetadata("6.kt") + public void test6() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/6.kt"); + } + + @Test + @TestMetadata("7.kt") + public void test7() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/7.kt"); + } + + @Test + @TestMetadata("8.kt") + public void test8() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/8.kt"); + } + + @Test + @TestMetadata("9.kt") + public void test9() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/9.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.kt") + public void test1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos/1.kt"); + } + + @Test + @TestMetadata("10.kt") + public void test10() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos/10.kt"); + } + + @Test + @TestMetadata("11.kt") + public void test11() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos/11.kt"); + } + + @Test + @TestMetadata("12.kt") + public void test12() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos/12.kt"); + } + + @Test + @TestMetadata("13.kt") + public void test13() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos/13.kt"); + } + + @Test + @TestMetadata("14.kt") + public void test14() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos/14.kt"); + } + + @Test + @TestMetadata("2.kt") + public void test2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos/2.kt"); + } + + @Test + @TestMetadata("3.kt") + public void test3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos/3.kt"); + } + + @Test + @TestMetadata("4.kt") + public void test4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos/4.kt"); + } + + @Test + @TestMetadata("5.kt") + public void test5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos/5.kt"); + } + + @Test + @TestMetadata("6.kt") + public void test6() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos/6.kt"); + } + + @Test + @TestMetadata("7.kt") + public void test7() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos/7.kt"); + } + + @Test + @TestMetadata("8.kt") + public void test8() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos/8.kt"); + } + + @Test + @TestMetadata("9.kt") + public void test9() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos/9.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations") + @TestDataPath("$PROJECT_ROOT") + public class Declarations { + @Test + public void testAllFilesPresentInDeclarations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder") + @TestDataPath("$PROJECT_ROOT") + public class ContractBuilder { + @Test + public void testAllFilesPresentInContractBuilder() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common") + @TestDataPath("$PROJECT_ROOT") + public class Common { + @Test + public void testAllFilesPresentInCommon() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.kt") + public void test1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/1.kt"); + } + + @Test + @TestMetadata("10.kt") + public void test10() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/10.kt"); + } + + @Test + @TestMetadata("11.kt") + public void test11() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/11.kt"); + } + + @Test + @TestMetadata("12.kt") + public void test12() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/12.kt"); + } + + @Test + @TestMetadata("13.kt") + public void test13() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/13.kt"); + } + + @Test + @TestMetadata("14.kt") + public void test14() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/14.kt"); + } + + @Test + @TestMetadata("15.kt") + public void test15() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/15.kt"); + } + + @Test + @TestMetadata("16.kt") + public void test16() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/16.kt"); + } + + @Test + @TestMetadata("17.kt") + public void test17() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/17.kt"); + } + + @Test + @TestMetadata("19.kt") + public void test19() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/19.kt"); + } + + @Test + @TestMetadata("2.kt") + public void test2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/2.kt"); + } + + @Test + @TestMetadata("3.kt") + public void test3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/3.kt"); + } + + @Test + @TestMetadata("4.kt") + public void test4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/4.kt"); + } + + @Test + @TestMetadata("5.kt") + public void test5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/5.kt"); + } + + @Test + @TestMetadata("6.kt") + public void test6() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/6.kt"); + } + + @Test + @TestMetadata("7.kt") + public void test7() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/7.kt"); + } + + @Test + @TestMetadata("8.kt") + public void test8() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/8.kt"); + } + + @Test + @TestMetadata("9.kt") + public void test9() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/9.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.kt") + public void test1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/pos/1.kt"); + } + + @Test + @TestMetadata("2.kt") + public void test2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/pos/2.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects") + @TestDataPath("$PROJECT_ROOT") + public class Effects { + @Test + public void testAllFilesPresentInEffects() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace") + @TestDataPath("$PROJECT_ROOT") + public class CallsInPlace { + @Test + public void testAllFilesPresentInCallsInPlace() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.kt") + public void test1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace/neg/1.kt"); + } + + @Test + @TestMetadata("2.kt") + public void test2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace/neg/2.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.kt") + public void test1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace/pos/1.kt"); + } + + @Test + @TestMetadata("2.kt") + public void test2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace/pos/2.kt"); + } + + @Test + @TestMetadata("3.kt") + public void test3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace/pos/3.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/common") + @TestDataPath("$PROJECT_ROOT") + public class Common { + @Test + public void testAllFilesPresentInCommon() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/common"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/common/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.kt") + public void test1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/common/neg/1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/common/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns") + @TestDataPath("$PROJECT_ROOT") + public class Returns { + @Test + public void testAllFilesPresentInReturns() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.kt") + public void test1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns/neg/1.kt"); + } + + @Test + @TestMetadata("2.kt") + public void test2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns/neg/2.kt"); + } + + @Test + @TestMetadata("3.kt") + public void test3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns/neg/3.kt"); + } + + @Test + @TestMetadata("4.kt") + public void test4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns/neg/4.kt"); + } + + @Test + @TestMetadata("5.kt") + public void test5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns/neg/5.kt"); + } + + @Test + @TestMetadata("6.kt") + public void test6() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns/neg/6.kt"); + } + + @Test + @TestMetadata("7.kt") + public void test7() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns/neg/7.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.kt") + public void test1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns/pos/1.kt"); + } + + @Test + @TestMetadata("2.kt") + public void test2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns/pos/2.kt"); + } + + @Test + @TestMetadata("3.kt") + public void test3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns/pos/3.kt"); + } + + @Test + @TestMetadata("4.kt") + public void test4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns/pos/4.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction") + @TestDataPath("$PROJECT_ROOT") + public class ContractFunction { + @Test + public void testAllFilesPresentInContractFunction() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.kt") + public void test1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction/neg/1.kt"); + } + + @Test + @TestMetadata("2.kt") + public void test2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction/neg/2.kt"); + } + + @Test + @TestMetadata("3.kt") + public void test3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction/neg/3.kt"); + } + + @Test + @TestMetadata("4.kt") + public void test4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction/neg/4.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.kt") + public void test1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction/pos/1.kt"); + } + + @Test + @TestMetadata("2.kt") + public void test2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction/pos/2.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/dfa") + @TestDataPath("$PROJECT_ROOT") + public class Dfa { + @Test + public void testAllFilesPresentInDfa() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/dfa"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.kt") + public void test1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/1.kt"); + } + + @Test + @TestMetadata("10.kt") + public void test10() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/10.kt"); + } + + @Test + @TestMetadata("11.kt") + public void test11() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/11.kt"); + } + + @Test + @TestMetadata("12.kt") + public void test12() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/12.kt"); + } + + @Test + @TestMetadata("13.kt") + public void test13() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/13.kt"); + } + + @Test + @TestMetadata("14.kt") + public void test14() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/14.kt"); + } + + @Test + @TestMetadata("15.kt") + public void test15() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/15.kt"); + } + + @Test + @TestMetadata("16.kt") + public void test16() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/16.kt"); + } + + @Test + @TestMetadata("17.kt") + public void test17() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/17.kt"); + } + + @Test + @TestMetadata("18.kt") + public void test18() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/18.kt"); + } + + @Test + @TestMetadata("19.kt") + public void test19() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/19.kt"); + } + + @Test + @TestMetadata("2.kt") + public void test2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/2.kt"); + } + + @Test + @TestMetadata("20.kt") + public void test20() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/20.kt"); + } + + @Test + @TestMetadata("21.kt") + public void test21() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/21.kt"); + } + + @Test + @TestMetadata("22.kt") + public void test22() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/22.kt"); + } + + @Test + @TestMetadata("23.kt") + public void test23() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/23.kt"); + } + + @Test + @TestMetadata("24.kt") + public void test24() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/24.kt"); + } + + @Test + @TestMetadata("25.kt") + public void test25() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/25.kt"); + } + + @Test + @TestMetadata("26.kt") + public void test26() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/26.kt"); + } + + @Test + @TestMetadata("27.kt") + public void test27() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/27.kt"); + } + + @Test + @TestMetadata("28.kt") + public void test28() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/28.kt"); + } + + @Test + @TestMetadata("29.kt") + public void test29() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/29.kt"); + } + + @Test + @TestMetadata("3.kt") + public void test3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/3.kt"); + } + + @Test + @TestMetadata("30.kt") + public void test30() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/30.kt"); + } + + @Test + @TestMetadata("31.kt") + public void test31() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/31.kt"); + } + + @Test + @TestMetadata("32.kt") + public void test32() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/32.kt"); + } + + @Test + @TestMetadata("33.kt") + public void test33() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/33.kt"); + } + + @Test + @TestMetadata("34.kt") + public void test34() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/34.kt"); + } + + @Test + @TestMetadata("35.kt") + public void test35() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/35.kt"); + } + + @Test + @TestMetadata("36.kt") + public void test36() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/36.kt"); + } + + @Test + @TestMetadata("37.kt") + public void test37() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/37.kt"); + } + + @Test + @TestMetadata("38.kt") + public void test38() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/38.kt"); + } + + @Test + @TestMetadata("39.kt") + public void test39() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/39.kt"); + } + + @Test + @TestMetadata("4.kt") + public void test4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/4.kt"); + } + + @Test + @TestMetadata("40.kt") + public void test40() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/40.kt"); + } + + @Test + @TestMetadata("41.kt") + public void test41() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/41.kt"); + } + + @Test + @TestMetadata("42.kt") + public void test42() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/42.kt"); + } + + @Test + @TestMetadata("43.kt") + public void test43() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/43.kt"); + } + + @Test + @TestMetadata("44.kt") + public void test44() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/44.kt"); + } + + @Test + @TestMetadata("45.kt") + public void test45() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/45.kt"); + } + + @Test + @TestMetadata("5.kt") + public void test5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/5.kt"); + } + + @Test + @TestMetadata("6.kt") + public void test6() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/6.kt"); + } + + @Test + @TestMetadata("7.kt") + public void test7() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/7.kt"); + } + + @Test + @TestMetadata("8.kt") + public void test8() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/8.kt"); + } + + @Test + @TestMetadata("9.kt") + public void test9() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/9.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.kt") + public void test1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/1.kt"); + } + + @Test + @TestMetadata("10.kt") + public void test10() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/10.kt"); + } + + @Test + @TestMetadata("11.kt") + public void test11() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/11.kt"); + } + + @Test + @TestMetadata("12.kt") + public void test12() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/12.kt"); + } + + @Test + @TestMetadata("13.kt") + public void test13() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/13.kt"); + } + + @Test + @TestMetadata("14.kt") + public void test14() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/14.kt"); + } + + @Test + @TestMetadata("15.kt") + public void test15() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/15.kt"); + } + + @Test + @TestMetadata("16.kt") + public void test16() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/16.kt"); + } + + @Test + @TestMetadata("17.kt") + public void test17() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/17.kt"); + } + + @Test + @TestMetadata("18.kt") + public void test18() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/18.kt"); + } + + @Test + @TestMetadata("19.kt") + public void test19() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/19.kt"); + } + + @Test + @TestMetadata("2.kt") + public void test2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/2.kt"); + } + + @Test + @TestMetadata("20.kt") + public void test20() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/20.kt"); + } + + @Test + @TestMetadata("21.kt") + public void test21() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/21.kt"); + } + + @Test + @TestMetadata("22.kt") + public void test22() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/22.kt"); + } + + @Test + @TestMetadata("23.kt") + public void test23() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/23.kt"); + } + + @Test + @TestMetadata("24.kt") + public void test24() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/24.kt"); + } + + @Test + @TestMetadata("25.kt") + public void test25() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/25.kt"); + } + + @Test + @TestMetadata("26.kt") + public void test26() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/26.kt"); + } + + @Test + @TestMetadata("27.kt") + public void test27() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/27.kt"); + } + + @Test + @TestMetadata("28.kt") + public void test28() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/28.kt"); + } + + @Test + @TestMetadata("29.kt") + public void test29() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/29.kt"); + } + + @Test + @TestMetadata("3.kt") + public void test3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/3.kt"); + } + + @Test + @TestMetadata("30.kt") + public void test30() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/30.kt"); + } + + @Test + @TestMetadata("31.kt") + public void test31() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/31.kt"); + } + + @Test + @TestMetadata("32.kt") + public void test32() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/32.kt"); + } + + @Test + @TestMetadata("33.kt") + public void test33() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/33.kt"); + } + + @Test + @TestMetadata("34.kt") + public void test34() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/34.kt"); + } + + @Test + @TestMetadata("35.kt") + public void test35() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/35.kt"); + } + + @Test + @TestMetadata("36.kt") + public void test36() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/36.kt"); + } + + @Test + @TestMetadata("37.kt") + public void test37() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/37.kt"); + } + + @Test + @TestMetadata("38.kt") + public void test38() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/38.kt"); + } + + @Test + @TestMetadata("39.kt") + public void test39() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/39.kt"); + } + + @Test + @TestMetadata("4.kt") + public void test4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/4.kt"); + } + + @Test + @TestMetadata("40.kt") + public void test40() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/40.kt"); + } + + @Test + @TestMetadata("41.kt") + public void test41() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/41.kt"); + } + + @Test + @TestMetadata("42.kt") + public void test42() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/42.kt"); + } + + @Test + @TestMetadata("43.kt") + public void test43() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/43.kt"); + } + + @Test + @TestMetadata("44.kt") + public void test44() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/44.kt"); + } + + @Test + @TestMetadata("45.kt") + public void test45() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/45.kt"); + } + + @Test + @TestMetadata("46.kt") + public void test46() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/46.kt"); + } + + @Test + @TestMetadata("47.kt") + public void test47() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/47.kt"); + } + + @Test + @TestMetadata("48.kt") + public void test48() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/48.kt"); + } + + @Test + @TestMetadata("49.kt") + public void test49() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/49.kt"); + } + + @Test + @TestMetadata("5.kt") + public void test5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/5.kt"); + } + + @Test + @TestMetadata("50.kt") + public void test50() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/50.kt"); + } + + @Test + @TestMetadata("51.kt") + public void test51() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/51.kt"); + } + + @Test + @TestMetadata("52.kt") + public void test52() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/52.kt"); + } + + @Test + @TestMetadata("53.kt") + public void test53() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/53.kt"); + } + + @Test + @TestMetadata("54.kt") + public void test54() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/54.kt"); + } + + @Test + @TestMetadata("55.kt") + public void test55() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/55.kt"); + } + + @Test + @TestMetadata("56.kt") + public void test56() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/56.kt"); + } + + @Test + @TestMetadata("57.kt") + public void test57() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/57.kt"); + } + + @Test + @TestMetadata("58.kt") + public void test58() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/58.kt"); + } + + @Test + @TestMetadata("59.kt") + public void test59() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/59.kt"); + } + + @Test + @TestMetadata("6.kt") + public void test6() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/6.kt"); + } + + @Test + @TestMetadata("60.kt") + public void test60() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/60.kt"); + } + + @Test + @TestMetadata("61.kt") + public void test61() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/61.kt"); + } + + @Test + @TestMetadata("62.kt") + public void test62() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/62.kt"); + } + + @Test + @TestMetadata("63.kt") + public void test63() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/63.kt"); + } + + @Test + @TestMetadata("64.kt") + public void test64() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/64.kt"); + } + + @Test + @TestMetadata("65.kt") + public void test65() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/65.kt"); + } + + @Test + @TestMetadata("66.kt") + public void test66() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/66.kt"); + } + + @Test + @TestMetadata("67.kt") + public void test67() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/67.kt"); + } + + @Test + @TestMetadata("68.kt") + public void test68() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/68.kt"); + } + + @Test + @TestMetadata("69.kt") + public void test69() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/69.kt"); + } + + @Test + @TestMetadata("7.kt") + public void test7() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/7.kt"); + } + + @Test + @TestMetadata("70.kt") + public void test70() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/70.kt"); + } + + @Test + @TestMetadata("71.kt") + public void test71() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/71.kt"); + } + + @Test + @TestMetadata("72.kt") + public void test72() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/72.kt"); + } + + @Test + @TestMetadata("73.kt") + public void test73() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/73.kt"); + } + + @Test + @TestMetadata("8.kt") + public void test8() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/8.kt"); + } + + @Test + @TestMetadata("9.kt") + public void test9() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/9.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/local-variables") + @TestDataPath("$PROJECT_ROOT") + public class Local_variables { + @Test + public void testAllFilesPresentInLocal_variables() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/local-variables"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/local-variables/type-parameters") + @TestDataPath("$PROJECT_ROOT") + public class Type_parameters { + @Test + public void testAllFilesPresentInType_parameters() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/local-variables/type-parameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/local-variables/type-parameters/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.kt") + public void test1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/local-variables/type-parameters/neg/1.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/local-variables/type-parameters/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/objects") + @TestDataPath("$PROJECT_ROOT") + public class Objects { + @Test + public void testAllFilesPresentInObjects() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/objects"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance") + @TestDataPath("$PROJECT_ROOT") + public class Inheritance { + @Test + public void testAllFilesPresentInInheritance() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg") + @TestDataPath("$PROJECT_ROOT") + public class Neg { + @Test + @TestMetadata("1.kt") + public void test1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/1.kt"); + } + + @Test + @TestMetadata("2.kt") + public void test2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/2.kt"); + } + + @Test + @TestMetadata("3.kt") + public void test3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/3.kt"); + } + + @Test + @TestMetadata("4.kt") + public void test4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/4.kt"); + } + + @Test + @TestMetadata("5.kt") + public void test5() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/5.kt"); + } + + @Test + @TestMetadata("6.kt") + public void test6() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/6.kt"); + } + + @Test + @TestMetadata("7.kt") + public void test7() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/7.kt"); + } + + @Test + public void testAllFilesPresentInNeg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution") + @TestDataPath("$PROJECT_ROOT") + public class Overload_resolution { + @Test + public void testAllFilesPresentInOverload_resolution() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs") + @TestDataPath("$PROJECT_ROOT") + public class Building_the_overload_candidate_set_ocs { + @Test + public void testAllFilesPresentInBuilding_the_overload_candidate_set_ocs() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call") + @TestDataPath("$PROJECT_ROOT") + public class Infix_function_call { + @Test + public void testAllFilesPresentInInfix_function_call() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + + @Nested + @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/pos") + @TestDataPath("$PROJECT_ROOT") + public class Pos { + @Test + @TestMetadata("1.kt") + public void test1() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/pos/1.kt"); + } + + @Test + @TestMetadata("2.kt") + public void test2() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/pos/2.kt"); + } + + @Test + @TestMetadata("3.kt") + public void test3() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/pos/3.kt"); + } + + @Test + @TestMetadata("4.kt") + public void test4() throws Exception { + runTest("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/pos/4.kt"); + } + + @Test + public void testAllFilesPresentInPos() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.(reversed|fir|ll)\\.kts?$"), true); + } + } + } + } + } + } +} diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/facades/LLFirAnalyzerFacadeFactory.kt b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/facades/LLFirAnalyzerFacadeFactory.kt new file mode 100644 index 00000000000..4a5042f51b2 --- /dev/null +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/facades/LLFirAnalyzerFacadeFactory.kt @@ -0,0 +1,20 @@ +/* + * 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.analysis.low.level.api.fir.diagnostic.compiler.based.facades + +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.DiagnosticCheckerFilter +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession +import org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based.LowLevelFirAnalyzerFacade +import org.jetbrains.kotlin.fir.declarations.FirFile +import org.jetbrains.kotlin.test.model.TestFile + +abstract class LLFirAnalyzerFacadeFactory { + abstract fun createFirFacade( + firResolveSession: LLFirResolveSession, + allFirFiles: Map, + diagnosticCheckerFilter: DiagnosticCheckerFilter + ): LowLevelFirAnalyzerFacade +} diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/facades/LLFirAnalyzerFacadeFactoryWithPreresolveInReversedOrder.kt b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/facades/LLFirAnalyzerFacadeFactoryWithPreresolveInReversedOrder.kt new file mode 100644 index 00000000000..3d24bac6ab6 --- /dev/null +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/facades/LLFirAnalyzerFacadeFactoryWithPreresolveInReversedOrder.kt @@ -0,0 +1,34 @@ +/* + * 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.analysis.low.level.api.fir.diagnostic.compiler.based.facades + +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.DiagnosticCheckerFilter +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession +import org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based.LowLevelFirAnalyzerFacade +import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase +import org.jetbrains.kotlin.fir.declarations.FirFile +import org.jetbrains.kotlin.fir.declarations.FirResolvePhase +import org.jetbrains.kotlin.test.model.TestFile +import org.jetbrains.kotlin.analysis.low.level.api.fir.getDeclarationsToResolve +import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase + +object LLFirAnalyzerFacadeFactoryWithPreresolveInReversedOrder : LLFirAnalyzerFacadeFactory() { + override fun createFirFacade( + firResolveSession: LLFirResolveSession, + allFirFiles: Map, + diagnosticCheckerFilter: DiagnosticCheckerFilter + ): LowLevelFirAnalyzerFacade = object : LowLevelFirAnalyzerFacade(firResolveSession, allFirFiles, diagnosticCheckerFilter) { + override fun runResolution(): List { + val allDeclarations = allFirFiles.values.getDeclarationsToResolve().reversed() + for (declaration in allDeclarations) { + declaration.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE) + declaration.checkPhase(FirResolvePhase.BODY_RESOLVE) + } + + return allFirFiles.values.toList() + } + } +} diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/facades/LLFirAnalyzerFacadeFactoryWithoutPreresolve.kt b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/facades/LLFirAnalyzerFacadeFactoryWithoutPreresolve.kt new file mode 100644 index 00000000000..51b9cc2755e --- /dev/null +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/facades/LLFirAnalyzerFacadeFactoryWithoutPreresolve.kt @@ -0,0 +1,22 @@ +/* + * 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.analysis.low.level.api.fir.diagnostic.compiler.based.facades + +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.DiagnosticCheckerFilter +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession +import org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based.LowLevelFirAnalyzerFacade +import org.jetbrains.kotlin.fir.declarations.FirFile +import org.jetbrains.kotlin.test.model.TestFile + +object LLFirAnalyzerFacadeFactoryWithoutPreresolve : LLFirAnalyzerFacadeFactory() { + override fun createFirFacade( + firResolveSession: LLFirResolveSession, + allFirFiles: Map, + diagnosticCheckerFilter: DiagnosticCheckerFilter + ): LowLevelFirAnalyzerFacade { + return LowLevelFirAnalyzerFacade(firResolveSession, allFirFiles, diagnosticCheckerFilter) + } +} diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/firTestUtils.kt b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/firTestUtils.kt index 3a1ef43ca7b..04bbea29a80 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/firTestUtils.kt +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/firTestUtils.kt @@ -1,5 +1,5 @@ /* - * 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. */ @@ -12,13 +12,11 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirSourceResolveS import org.jetbrains.kotlin.analysis.project.structure.getKtModule import org.jetbrains.kotlin.analysis.test.framework.services.environmentManager import org.jetbrains.kotlin.fir.FirElement -import org.jetbrains.kotlin.fir.declarations.FirDeclaration +import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.render import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousInitializerSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirFileSymbol +import org.jetbrains.kotlin.fir.symbols.impl.* +import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid import org.jetbrains.kotlin.psi.KtElement import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder import org.jetbrains.kotlin.test.services.PreAnalysisHandler @@ -64,4 +62,24 @@ internal fun TestConfigurationBuilder.useFirSessionConfigurator(configurator: (T } usePreAnalysisHandlers(::ConfiguratorPreAnalysisHandler) -} \ No newline at end of file +} + +inline fun FirElement.collectAllElementsOfType(): List { + val result = mutableListOf() + this.accept(object : FirVisitorVoid() { + override fun visitElement(element: FirElement) { + if (element is E) result += element + element.acceptChildren(this) + } + + }) + + return result +} + +fun Collection.getDeclarationsToResolve() = flatMap { it.collectAllElementsOfType() }.filterNot { declaration -> + declaration is FirFile || + declaration is FirBackingField || + declaration is FirAnonymousFunction || + declaration is FirValueParameter && declaration.containingFunctionSymbol is FirAnonymousFunctionSymbol +} diff --git a/compiler/fir/analysis-tests/testData/resolve/annotationOnDeclarationWithDifferentArguments.kt b/compiler/fir/analysis-tests/testData/resolve/annotationOnDeclarationWithDifferentArguments.kt index e7d4b1a3414..a47500009bf 100644 --- a/compiler/fir/analysis-tests/testData/resolve/annotationOnDeclarationWithDifferentArguments.kt +++ b/compiler/fir/analysis-tests/testData/resolve/annotationOnDeclarationWithDifferentArguments.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE import kotlin.reflect.KClass enum class SomeEnum { diff --git a/compiler/fir/analysis-tests/testData/resolve/cfa/reassignOfNonLocalProperty_initializedProperties.kt b/compiler/fir/analysis-tests/testData/resolve/cfa/reassignOfNonLocalProperty_initializedProperties.kt index 5d5a2c458d1..08044301684 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfa/reassignOfNonLocalProperty_initializedProperties.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfa/reassignOfNonLocalProperty_initializedProperties.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // ISSUE: KT-55493 // WITH_STDLIB diff --git a/compiler/fir/analysis-tests/testData/resolve/cfa/reassignOfNonMemberProperty_lateInitialization.kt b/compiler/fir/analysis-tests/testData/resolve/cfa/reassignOfNonMemberProperty_lateInitialization.kt index d9dd5c0828d..e576076acba 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfa/reassignOfNonMemberProperty_lateInitialization.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfa/reassignOfNonMemberProperty_lateInitialization.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // ISSUE: KT-55493 // WITH_STDLIB diff --git a/compiler/fir/analysis-tests/testData/resolve/cfa/smartcastOnThisDuringClassInitialization.kt b/compiler/fir/analysis-tests/testData/resolve/cfa/smartcastOnThisDuringClassInitialization.kt index d450c98948a..1f60296a3f6 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfa/smartcastOnThisDuringClassInitialization.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfa/smartcastOnThisDuringClassInitialization.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // ISSUE: KT-56863 interface I diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/annotatedLocalClass.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/annotatedLocalClass.kt index 794013aabe4..5b1883cde87 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfg/annotatedLocalClass.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfg/annotatedLocalClass.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG annotation class Ann diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/complex.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/complex.kt index 064c92a92d7..f8af1f9d020 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfg/complex.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfg/complex.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG interface AutoCloseable { fun close() diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/initBlock.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/initBlock.kt index 53799431123..1ba10334688 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfg/initBlock.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfg/initBlock.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG class Foo { init { diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/initBlockAndInPlaceLambda.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/initBlockAndInPlaceLambda.kt index 06f6dffba56..e17648d5fa6 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfg/initBlockAndInPlaceLambda.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfg/initBlockAndInPlaceLambda.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG interface B diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/lambdaReturningObject.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/lambdaReturningObject.kt index 0cf43a7165a..21990b7de25 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfg/lambdaReturningObject.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfg/lambdaReturningObject.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG interface Out diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdaInConstructor.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdaInConstructor.kt index 302d1b95bf8..da0030b9556 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdaInConstructor.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdaInConstructor.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG abstract class A(func: () -> String) diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdaInReturn.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdaInReturn.kt index 8559de2a0b6..d6a8d51ced2 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdaInReturn.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdaInReturn.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG import kotlin.contracts.* diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/returnValuesFromLambda.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/returnValuesFromLambda.kt index e0d1b079569..20890ed7f7f 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfg/returnValuesFromLambda.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfg/returnValuesFromLambda.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG interface A diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/safeCalls.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/safeCalls.kt index f1e8859e0bc..a79555c2a90 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfg/safeCalls.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfg/safeCalls.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG interface A { fun foo(): A diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeConst.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeConst.kt index 86984c64a8d..4e3c33606c8 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeConst.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeConst.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE annotation class Ann1(vararg val a: String) annotation class Ann2(val a: IntArray) annotation class Ann3(val a: Array) diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeKClassLiteral.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeKClassLiteral.kt index f32955807db..6f051ccf8f1 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeKClassLiteral.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeKClassLiteral.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE import kotlin.reflect.KClass @Repeatable diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationClassMember.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationClassMember.kt index c216b670713..908260933f4 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationClassMember.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationClassMember.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE annotation class A() { constructor(s: Nothing?) {} init {} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/nonConstValInAnnotationArgument.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/nonConstValInAnnotationArgument.kt index 8a9dfbb7c40..5b3c57a00ee 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/nonConstValInAnnotationArgument.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/nonConstValInAnnotationArgument.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE annotation class Ann(val a: Array) val foo = "" diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/propertyTypeMismatchOnOverride.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/propertyTypeMismatchOnOverride.kt index 85502ea44e4..5353dde97f8 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/propertyTypeMismatchOnOverride.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/propertyTypeMismatchOnOverride.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE open class A { open var test: Number = 10 } diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/repeatedModifier.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/repeatedModifier.kt index adbb0b1c8a3..e48b6b4c649 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/repeatedModifier.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/repeatedModifier.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE open open class A internal internal object B diff --git a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/exhaustiveWhenAndDNNType.kt b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/exhaustiveWhenAndDNNType.kt index be8412c5e42..5a7621a7791 100644 --- a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/exhaustiveWhenAndDNNType.kt +++ b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness/positive/exhaustiveWhenAndDNNType.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG // ISSUE: KT-37091 diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/CallBasedInExpressionGenerator.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/CallBasedInExpressionGenerator.kt index 0284552e9c9..b068490f9e2 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/CallBasedInExpressionGenerator.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/CallBasedInExpressionGenerator.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE package org.jetbrains.kotlin.codegen.range.inExpression interface ExpressionCodegen diff --git a/compiler/fir/analysis-tests/testData/resolve/fromBuilder/noPrimaryConstructor.kt b/compiler/fir/analysis-tests/testData/resolve/fromBuilder/noPrimaryConstructor.kt index 5f0a3dcd069..db20c9ba0a5 100644 --- a/compiler/fir/analysis-tests/testData/resolve/fromBuilder/noPrimaryConstructor.kt +++ b/compiler/fir/analysis-tests/testData/resolve/fromBuilder/noPrimaryConstructor.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class NoPrimary { val x: String diff --git a/compiler/fir/analysis-tests/testData/resolve/lambdaPropertyTypeInference.kt b/compiler/fir/analysis-tests/testData/resolve/lambdaPropertyTypeInference.kt index f69c1b469b6..ce117889151 100644 --- a/compiler/fir/analysis-tests/testData/resolve/lambdaPropertyTypeInference.kt +++ b/compiler/fir/analysis-tests/testData/resolve/lambdaPropertyTypeInference.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !CHECK_TYPE // UNEXPECTED BEHAVIOUR // ISSUES: KT-37066 diff --git a/compiler/fir/analysis-tests/testData/resolve/problems/kt42346.kt b/compiler/fir/analysis-tests/testData/resolve/problems/kt42346.kt index 045eced24e1..512580a0b9c 100644 --- a/compiler/fir/analysis-tests/testData/resolve/problems/kt42346.kt +++ b/compiler/fir/analysis-tests/testData/resolve/problems/kt42346.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FILE: MagicConstant.java public @interface MagicConstant { diff --git a/compiler/fir/analysis-tests/testData/resolve/problems/secondaryConstructorCfg.kt b/compiler/fir/analysis-tests/testData/resolve/problems/secondaryConstructorCfg.kt index 4eab56422cc..a31f58b9a45 100644 --- a/compiler/fir/analysis-tests/testData/resolve/problems/secondaryConstructorCfg.kt +++ b/compiler/fir/analysis-tests/testData/resolve/problems/secondaryConstructorCfg.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG class B(p0: String) { val p1 = p0 diff --git a/compiler/fir/analysis-tests/testData/resolve/problems/transform.kt b/compiler/fir/analysis-tests/testData/resolve/problems/transform.kt index a87acd4fd3e..d7dc83f5b6e 100644 --- a/compiler/fir/analysis-tests/testData/resolve/problems/transform.kt +++ b/compiler/fir/analysis-tests/testData/resolve/problems/transform.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE interface FirElement { fun accept(visitor: FirVisitor, data: D): R diff --git a/compiler/fir/analysis-tests/testData/resolve/scopes/kotlinAccessorsLikeFunctionsThrowJavaClass.kt b/compiler/fir/analysis-tests/testData/resolve/scopes/kotlinAccessorsLikeFunctionsThrowJavaClass.kt index 92be1b74eac..3c8cd07490e 100644 --- a/compiler/fir/analysis-tests/testData/resolve/scopes/kotlinAccessorsLikeFunctionsThrowJavaClass.kt +++ b/compiler/fir/analysis-tests/testData/resolve/scopes/kotlinAccessorsLikeFunctionsThrowJavaClass.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FILE: A.kt open class A { open fun getScope(): String? = null diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/bangbang.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/bangbang.kt index 327e8273b11..034fdd1db98 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/bangbang.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/bangbang.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG interface A { fun foo(): Boolean diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/booleanOperators.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/booleanOperators.kt index 4f293d49cd0..86c8efa0a68 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/booleanOperators.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/booleanOperators.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG interface A { fun foo() diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/equalsToBoolean.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/equalsToBoolean.kt index f954bff67f3..8aa65dd526c 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/equalsToBoolean.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/equalsToBoolean.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG interface A { fun foo() diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/jumpFromRhsOfOperator.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/jumpFromRhsOfOperator.kt index 076f593e151..28566f4aa1b 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/jumpFromRhsOfOperator.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/jumpFromRhsOfOperator.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG interface A { diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcasts.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcasts.kt index 148f8af2c9b..96c37389f9e 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcasts.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcasts.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG interface A { fun foo() diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcastsInBranches.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcastsInBranches.kt index 22feafe6f32..d2e7db746a0 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcastsInBranches.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcastsInBranches.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG class A { val s: String = "" diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/functionCallBound.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/functionCallBound.kt index d40567e90db..5d4512b87e7 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/functionCallBound.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/functionCallBound.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG open class Base diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/elvis.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/elvis.kt index 8891abd774d..d9bb35a7d50 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/elvis.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/elvis.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG interface A { fun foo() diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/returns.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/returns.kt index cacf8dcd98e..39194b8b0c3 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/returns.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/returns.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG fun test_0(x: Any) { if (x is String) { diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/smartcastFromArgument.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/smartcastFromArgument.kt index 3ce26ed8eea..013d25677e2 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/smartcastFromArgument.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/smartcastFromArgument.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG interface A { fun foo() diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/when.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/when.kt index a5e84e1accd..b2cceb0107a 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/when.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/when.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG interface A { fun foo() diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/equalsAndIdentity.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/equalsAndIdentity.kt index fcf5c715f73..83530aec682 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/equalsAndIdentity.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/equalsAndIdentity.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG interface A { fun foo() diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/inPlaceLambdas.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/inPlaceLambdas.kt index abc7a141b50..0623d39d291 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/inPlaceLambdas.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/inPlaceLambdas.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG interface A { fun foo() diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/lambdaInWhenBranch.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/lambdaInWhenBranch.kt index 8f1be2f0d9d..ba63b24b295 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/lambdaInWhenBranch.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/lambdaInWhenBranch.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // ISSUE: KT-39080 // !DUMP_CFG diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/dataFlowInfoFromWhileCondition.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/dataFlowInfoFromWhileCondition.kt index 7008375bcb0..c66d69761ed 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/dataFlowInfoFromWhileCondition.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/dataFlowInfoFromWhileCondition.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG interface A { fun foo(): Boolean diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/endlessLoops.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/endlessLoops.kt index 1776f00f971..c3180ab8cc5 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/endlessLoops.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/endlessLoops.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG interface A { fun foo() diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/multipleCasts.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/multipleCasts.kt index c9b0b837694..bc211b39e39 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/multipleCasts.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/multipleCasts.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG // There would be ambiguities if some expression was smartcasted to (A & B) and foo() was called. // There was a bug where 2 variables were "bound" together if they are assigned from the same function call or property. diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/nullability.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/nullability.kt index 20fc39b20ad..872fc7d95d3 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/nullability.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/nullability.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG // CONTAINS ERRORS diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/implicitReceivers.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/implicitReceivers.kt index b1ddb729fcc..04ba79c149e 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/implicitReceivers.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/implicitReceivers.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG class A { fun foo() {} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/assignSafeCall.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/assignSafeCall.kt index 8e51020f74a..8c0cc813ee5 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/assignSafeCall.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/assignSafeCall.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG // ----------------- Stable ----------------- diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCalls.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCalls.kt index 3c681bde320..13c8c3d2ea5 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCalls.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCalls.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG fun String.foo(b: Boolean): String = "" diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/smartCastInInit.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/smartCastInInit.kt index 6c04bd27d89..e41e93d116e 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/smartCastInInit.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/smartCastInInit.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG interface I interface S : I { diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/smartcastInByClause.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/smartcastInByClause.kt index 0ce7e645d12..2a4800dc88a 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/smartcastInByClause.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/smartcastInByClause.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // ISSUE: KT-49747 // DUMP_CFG diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/smartcastToNothing.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/smartcastToNothing.kt index 7bf0acfa9b3..19822b1349f 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/smartcastToNothing.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/smartcastToNothing.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG fun getNothing(): Nothing = throw Exception() fun getNullableNothing(): Nothing? = null diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/stability/overridenOpenVal.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/stability/overridenOpenVal.kt index 98b6ef64964..ba2a7d16017 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/stability/overridenOpenVal.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/stability/overridenOpenVal.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG open class A(open val x: Any) diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/delayedAssignment.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/delayedAssignment.kt index 05c62c6d6d5..3261a82411c 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/delayedAssignment.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/delayedAssignment.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG class A { fun foo() {} diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.kt index 6298db84ebc..dc9e8ea9078 100644 --- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.kt +++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE fun use(x: (T) -> R): (T) -> R = x fun foo() = use(::bar) diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/delegateWithAnonymousObject.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/delegateWithAnonymousObject.kt index 8bfe0d4bc69..4382aadd0f3 100644 --- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/delegateWithAnonymousObject.kt +++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/delegateWithAnonymousObject.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DUMP_CFG import kotlin.properties.ReadWriteProperty diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/simpleDelegatedToMap.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/simpleDelegatedToMap.kt index 09535d63d34..05ad315b70f 100644 --- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/simpleDelegatedToMap.kt +++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/simpleDelegatedToMap.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class C(val map: MutableMap) { var foo by map } diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/plusAssignWithLambdaInRhs.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/plusAssignWithLambdaInRhs.kt index a2248ca2899..1b898adc027 100644 --- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/plusAssignWithLambdaInRhs.kt +++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/plusAssignWithLambdaInRhs.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // ISSUE: KT-39005 // !DUMP_CFG diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/backingFieldVisibility.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/backingFieldVisibility.kt index 963c85ae7c9..0f6cce3f0f9 100644 --- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/backingFieldVisibility.kt +++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/backingFieldVisibility.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // MODULE: lib // FILE: A.kt diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/backingFieldWithSmartTypeParameters.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/backingFieldWithSmartTypeParameters.kt index 7fe46de630b..9fcb84e4582 100644 --- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/backingFieldWithSmartTypeParameters.kt +++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/backingFieldWithSmartTypeParameters.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE val items: List field = mutableListOf() diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/filePrivateBackingFieldAccess.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/filePrivateBackingFieldAccess.kt index d71b5697aaa..a4fa40b24b4 100644 --- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/filePrivateBackingFieldAccess.kt +++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/filePrivateBackingFieldAccess.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE val list: List field = mutableListOf() diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/propertyTypeNarrowing.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/propertyTypeNarrowing.kt index ebd1d9e3ca0..de197cb4aef 100644 --- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/propertyTypeNarrowing.kt +++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/properties/backingField/propertyTypeNarrowing.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class A { val it: Number field = 4 diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/reinitializations/constructorVarWrite.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/reinitializations/constructorVarWrite.kt index 3d4e5944d22..15425f08f84 100644 --- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/reinitializations/constructorVarWrite.kt +++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/reinitializations/constructorVarWrite.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class Some(var foo: Int) { init { if (foo < 0) { diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/runOnIntegerLiteral.kt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/runOnIntegerLiteral.kt index ad72a5de69a..8afc58c9743 100644 --- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/runOnIntegerLiteral.kt +++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/runOnIntegerLiteral.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class TestInitValInLambdaCalledOnce { val x: Int init { diff --git a/compiler/testData/diagnostics/tests/AnonymousInitializerVarAndConstructor.kt b/compiler/testData/diagnostics/tests/AnonymousInitializerVarAndConstructor.kt index 34b70b7c831..843f309ff7a 100644 --- a/compiler/testData/diagnostics/tests/AnonymousInitializerVarAndConstructor.kt +++ b/compiler/testData/diagnostics/tests/AnonymousInitializerVarAndConstructor.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // http://youtrack.jetbrains.net/issue/KT-419 diff --git a/compiler/testData/diagnostics/tests/AnonymousInitializers.kt b/compiler/testData/diagnostics/tests/AnonymousInitializers.kt index a4d7e84ce95..7e46c4fd67e 100644 --- a/compiler/testData/diagnostics/tests/AnonymousInitializers.kt +++ b/compiler/testData/diagnostics/tests/AnonymousInitializers.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL interface NoC { init { diff --git a/compiler/testData/diagnostics/tests/BacktickNames.kt b/compiler/testData/diagnostics/tests/BacktickNames.kt index 064ed03ceab..21309baf7b2 100644 --- a/compiler/testData/diagnostics/tests/BacktickNames.kt +++ b/compiler/testData/diagnostics/tests/BacktickNames.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER -UNUSED_ANONYMOUS_PARAMETER // TODO Uncomment all the examples when there will be no problems with light classes diff --git a/compiler/testData/diagnostics/tests/FreeFunctionCalledAsExtension.fir.kt b/compiler/testData/diagnostics/tests/FreeFunctionCalledAsExtension.fir.kt index 140ff3919a6..9acfe8bc214 100644 --- a/compiler/testData/diagnostics/tests/FreeFunctionCalledAsExtension.fir.kt +++ b/compiler/testData/diagnostics/tests/FreeFunctionCalledAsExtension.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE fun foo(a: (String) -> Unit) { "".a() } diff --git a/compiler/testData/diagnostics/tests/FreeFunctionCalledAsExtension.kt b/compiler/testData/diagnostics/tests/FreeFunctionCalledAsExtension.kt index b742d3ccb3c..3770aaffe43 100644 --- a/compiler/testData/diagnostics/tests/FreeFunctionCalledAsExtension.kt +++ b/compiler/testData/diagnostics/tests/FreeFunctionCalledAsExtension.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE fun foo(a: (String) -> Unit) { "".a() } diff --git a/compiler/testData/diagnostics/tests/UnusedParameters.fir.kt b/compiler/testData/diagnostics/tests/UnusedParameters.fir.kt index 5fc389588e2..ae593e35158 100644 --- a/compiler/testData/diagnostics/tests/UnusedParameters.fir.kt +++ b/compiler/testData/diagnostics/tests/UnusedParameters.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: +UNUSED_PARAMETER import kotlin.reflect.KProperty diff --git a/compiler/testData/diagnostics/tests/UnusedParameters.kt b/compiler/testData/diagnostics/tests/UnusedParameters.kt index 881d669d07b..4640e67d750 100644 --- a/compiler/testData/diagnostics/tests/UnusedParameters.kt +++ b/compiler/testData/diagnostics/tests/UnusedParameters.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: +UNUSED_PARAMETER import kotlin.reflect.KProperty diff --git a/compiler/testData/diagnostics/tests/UnusedVariables.fir.kt b/compiler/testData/diagnostics/tests/UnusedVariables.fir.kt index e85563ff10a..e5f6fdb375e 100644 --- a/compiler/testData/diagnostics/tests/UnusedVariables.fir.kt +++ b/compiler/testData/diagnostics/tests/UnusedVariables.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: +UNUSED_VALUE, +UNUSED_CHANGED_VALUE, +UNUSED_PARAMETER, +UNUSED_VARIABLE package unused_variables diff --git a/compiler/testData/diagnostics/tests/UnusedVariables.kt b/compiler/testData/diagnostics/tests/UnusedVariables.kt index 7e9de849969..10913ae68c1 100644 --- a/compiler/testData/diagnostics/tests/UnusedVariables.kt +++ b/compiler/testData/diagnostics/tests/UnusedVariables.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: +UNUSED_VALUE, +UNUSED_CHANGED_VALUE, +UNUSED_PARAMETER, +UNUSED_VARIABLE package unused_variables diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_15.fir.kt b/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_15.fir.kt index a8af099615e..12f320d7eac 100644 --- a/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_15.fir.kt +++ b/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_15.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ClassTypeParameterAnnotations @Target(AnnotationTarget.TYPE_PARAMETER) annotation class A1 diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_15.kt b/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_15.kt index d18a863ca09..46e66c07735 100644 --- a/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_15.kt +++ b/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_15.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ClassTypeParameterAnnotations @Target(AnnotationTarget.TYPE_PARAMETER) annotation class A1 diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_16.fir.kt b/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_16.fir.kt index 5a5c24f05f4..5920cc2c08b 100644 --- a/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_16.fir.kt +++ b/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_16.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: +ClassTypeParameterAnnotations annotation class A1 annotation class A2(val some: Int = 12) diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_16.kt b/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_16.kt index 9609940be74..5a6e675a575 100644 --- a/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_16.kt +++ b/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_16.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: +ClassTypeParameterAnnotations annotation class A1 annotation class A2(val some: Int = 12) diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_typeUseFlag.fir.kt b/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_typeUseFlag.fir.kt index 712294271fb..a6d1dbd7898 100644 --- a/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_typeUseFlag.fir.kt +++ b/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_typeUseFlag.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: +ProperCheckAnnotationsTargetInTypeUsePositions -ClassTypeParameterAnnotations annotation class A1 diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_typeUseFlag.kt b/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_typeUseFlag.kt index d4f93f004da..1f9f1aa665b 100644 --- a/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_typeUseFlag.kt +++ b/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter_typeUseFlag.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: +ProperCheckAnnotationsTargetInTypeUsePositions -ClassTypeParameterAnnotations annotation class A1 diff --git a/compiler/testData/diagnostics/tests/annotations/MutuallyRecursivelyAnnotatedGlobalFunction.fir.kt b/compiler/testData/diagnostics/tests/annotations/MutuallyRecursivelyAnnotatedGlobalFunction.fir.kt index 21c3066e89b..4dac3e7ca5f 100644 --- a/compiler/testData/diagnostics/tests/annotations/MutuallyRecursivelyAnnotatedGlobalFunction.fir.kt +++ b/compiler/testData/diagnostics/tests/annotations/MutuallyRecursivelyAnnotatedGlobalFunction.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // Functions can be recursively annotated annotation class ann(val x: Int) @ann(bar()) fun foo() = 1 diff --git a/compiler/testData/diagnostics/tests/annotations/MutuallyRecursivelyAnnotatedGlobalFunction.kt b/compiler/testData/diagnostics/tests/annotations/MutuallyRecursivelyAnnotatedGlobalFunction.kt index 552ec93b99e..58cac24bed1 100644 --- a/compiler/testData/diagnostics/tests/annotations/MutuallyRecursivelyAnnotatedGlobalFunction.kt +++ b/compiler/testData/diagnostics/tests/annotations/MutuallyRecursivelyAnnotatedGlobalFunction.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // Functions can be recursively annotated annotation class ann(val x: Int) @ann(bar()) fun foo() = 1 diff --git a/compiler/testData/diagnostics/tests/annotations/annotationOnParameterInFunctionType.fir.kt b/compiler/testData/diagnostics/tests/annotations/annotationOnParameterInFunctionType.fir.kt index d3d97bf937f..2a6a5672bb1 100644 --- a/compiler/testData/diagnostics/tests/annotations/annotationOnParameterInFunctionType.fir.kt +++ b/compiler/testData/diagnostics/tests/annotations/annotationOnParameterInFunctionType.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE annotation class Ann diff --git a/compiler/testData/diagnostics/tests/annotations/annotationOnParameterInFunctionType.kt b/compiler/testData/diagnostics/tests/annotations/annotationOnParameterInFunctionType.kt index 40b059b4ffe..2641bd13ae4 100644 --- a/compiler/testData/diagnostics/tests/annotations/annotationOnParameterInFunctionType.kt +++ b/compiler/testData/diagnostics/tests/annotations/annotationOnParameterInFunctionType.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE annotation class Ann diff --git a/compiler/testData/diagnostics/tests/annotations/kt1886annotationBody_after.kt b/compiler/testData/diagnostics/tests/annotations/kt1886annotationBody_after.kt index c979c7ed8f5..27a7c423242 100644 --- a/compiler/testData/diagnostics/tests/annotations/kt1886annotationBody_after.kt +++ b/compiler/testData/diagnostics/tests/annotations/kt1886annotationBody_after.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !LANGUAGE: +NestedClassesInAnnotations diff --git a/compiler/testData/diagnostics/tests/annotations/kt1886annotationBody_before.fir.kt b/compiler/testData/diagnostics/tests/annotations/kt1886annotationBody_before.fir.kt index 4d6bebd4ced..16ffdc79cff 100644 --- a/compiler/testData/diagnostics/tests/annotations/kt1886annotationBody_before.fir.kt +++ b/compiler/testData/diagnostics/tests/annotations/kt1886annotationBody_before.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -NestedClassesInAnnotations annotation class Annotation2() { diff --git a/compiler/testData/diagnostics/tests/annotations/kt1886annotationBody_before.kt b/compiler/testData/diagnostics/tests/annotations/kt1886annotationBody_before.kt index b8d0118a25c..a32b7240729 100644 --- a/compiler/testData/diagnostics/tests/annotations/kt1886annotationBody_before.kt +++ b/compiler/testData/diagnostics/tests/annotations/kt1886annotationBody_before.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -NestedClassesInAnnotations annotation class Annotation2() { diff --git a/compiler/testData/diagnostics/tests/annotations/nestedClassesInAnnotations.kt b/compiler/testData/diagnostics/tests/annotations/nestedClassesInAnnotations.kt index 14801a4af9a..20335210db6 100644 --- a/compiler/testData/diagnostics/tests/annotations/nestedClassesInAnnotations.kt +++ b/compiler/testData/diagnostics/tests/annotations/nestedClassesInAnnotations.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !LANGUAGE: +NestedClassesInAnnotations diff --git a/compiler/testData/diagnostics/tests/annotations/onInitializer.fir.kt b/compiler/testData/diagnostics/tests/annotations/onInitializer.fir.kt index ae9955da41e..a951ac85cb2 100644 --- a/compiler/testData/diagnostics/tests/annotations/onInitializer.fir.kt +++ b/compiler/testData/diagnostics/tests/annotations/onInitializer.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class A { @ann init {} @aaa init {} diff --git a/compiler/testData/diagnostics/tests/annotations/onInitializer.kt b/compiler/testData/diagnostics/tests/annotations/onInitializer.kt index 355fdd3cec3..20b5e769187 100644 --- a/compiler/testData/diagnostics/tests/annotations/onInitializer.kt +++ b/compiler/testData/diagnostics/tests/annotations/onInitializer.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class A { @ann init {} @aaa init {} diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/init.fir.kt b/compiler/testData/diagnostics/tests/annotations/options/targets/init.fir.kt index b69a5251d59..0a92f60c9a9 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/targets/init.fir.kt +++ b/compiler/testData/diagnostics/tests/annotations/options/targets/init.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE annotation class base @base class My { diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/init.kt b/compiler/testData/diagnostics/tests/annotations/options/targets/init.kt index a213d178a1d..99f24bbec10 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/targets/init.kt +++ b/compiler/testData/diagnostics/tests/annotations/options/targets/init.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE annotation class base @base class My { diff --git a/compiler/testData/diagnostics/tests/annotations/parameters/expressions/gt.kt b/compiler/testData/diagnostics/tests/annotations/parameters/expressions/gt.kt index be2e5ebe2ab..2718049055a 100644 --- a/compiler/testData/diagnostics/tests/annotations/parameters/expressions/gt.kt +++ b/compiler/testData/diagnostics/tests/annotations/parameters/expressions/gt.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !LANGUAGE: -ProhibitSimplificationOfNonTrivialConstBooleanExpressions package test diff --git a/compiler/testData/diagnostics/tests/annotations/parameters/expressions/lt.kt b/compiler/testData/diagnostics/tests/annotations/parameters/expressions/lt.kt index 6e09f6bb613..61e011aa204 100644 --- a/compiler/testData/diagnostics/tests/annotations/parameters/expressions/lt.kt +++ b/compiler/testData/diagnostics/tests/annotations/parameters/expressions/lt.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !LANGUAGE: -ProhibitSimplificationOfNonTrivialConstBooleanExpressions package test diff --git a/compiler/testData/diagnostics/tests/annotations/typeAnnotations.fir.kt b/compiler/testData/diagnostics/tests/annotations/typeAnnotations.fir.kt index 11ced1d6401..222b4c0d772 100644 --- a/compiler/testData/diagnostics/tests/annotations/typeAnnotations.fir.kt +++ b/compiler/testData/diagnostics/tests/annotations/typeAnnotations.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_VARIABLE, -UNUSED_PARAMETER class A diff --git a/compiler/testData/diagnostics/tests/annotations/typeAnnotations.kt b/compiler/testData/diagnostics/tests/annotations/typeAnnotations.kt index 8ce2e4916bc..5bdc1f6e0c7 100644 --- a/compiler/testData/diagnostics/tests/annotations/typeAnnotations.kt +++ b/compiler/testData/diagnostics/tests/annotations/typeAnnotations.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_VARIABLE, -UNUSED_PARAMETER class A diff --git a/compiler/testData/diagnostics/tests/backingField/InitCustomSetter.fir.kt b/compiler/testData/diagnostics/tests/backingField/InitCustomSetter.fir.kt index c39035d89e1..4b154c6343f 100644 --- a/compiler/testData/diagnostics/tests/backingField/InitCustomSetter.fir.kt +++ b/compiler/testData/diagnostics/tests/backingField/InitCustomSetter.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class My(val v: Int) { // Ok: setter is just private var x: Int diff --git a/compiler/testData/diagnostics/tests/backingField/InitCustomSetter.kt b/compiler/testData/diagnostics/tests/backingField/InitCustomSetter.kt index 11c04fa4808..e69b91037b7 100644 --- a/compiler/testData/diagnostics/tests/backingField/InitCustomSetter.kt +++ b/compiler/testData/diagnostics/tests/backingField/InitCustomSetter.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class My(val v: Int) { // Ok: setter is just private var x: Int diff --git a/compiler/testData/diagnostics/tests/backingField/InitOpenSetter.fir.kt b/compiler/testData/diagnostics/tests/backingField/InitOpenSetter.fir.kt index bbc5ecea2c8..2f646c87b66 100644 --- a/compiler/testData/diagnostics/tests/backingField/InitOpenSetter.fir.kt +++ b/compiler/testData/diagnostics/tests/backingField/InitOpenSetter.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE abstract class My(val v: Int) { // Ok: variable is just abstract abstract var x: Int diff --git a/compiler/testData/diagnostics/tests/backingField/InitOpenSetter.kt b/compiler/testData/diagnostics/tests/backingField/InitOpenSetter.kt index b708cdd35d7..628c6d27d2d 100644 --- a/compiler/testData/diagnostics/tests/backingField/InitOpenSetter.kt +++ b/compiler/testData/diagnostics/tests/backingField/InitOpenSetter.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE abstract class My(val v: Int) { // Ok: variable is just abstract abstract var x: Int diff --git a/compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax3.fir.kt b/compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax3.fir.kt index 42cc0877a3d..08962c867a3 100644 --- a/compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax3.fir.kt +++ b/compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax3.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_VARIABLE package test diff --git a/compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax3.kt b/compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax3.kt index 7ffa2ef0e6a..524fbd30d70 100644 --- a/compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax3.kt +++ b/compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax3.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_VARIABLE package test diff --git a/compiler/testData/diagnostics/tests/callableReference/kt7430_wrongClassOnLHS.kt b/compiler/testData/diagnostics/tests/callableReference/kt7430_wrongClassOnLHS.kt index d0c9efc77e5..e00891d749f 100644 --- a/compiler/testData/diagnostics/tests/callableReference/kt7430_wrongClassOnLHS.kt +++ b/compiler/testData/diagnostics/tests/callableReference/kt7430_wrongClassOnLHS.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_EXPRESSION diff --git a/compiler/testData/diagnostics/tests/callableReference/property/genericClass.kt b/compiler/testData/diagnostics/tests/callableReference/property/genericClass.kt index 94a01d13be1..4e7b6416d66 100644 --- a/compiler/testData/diagnostics/tests/callableReference/property/genericClass.kt +++ b/compiler/testData/diagnostics/tests/callableReference/property/genericClass.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !CHECK_TYPE diff --git a/compiler/testData/diagnostics/tests/classLiteral/inAnnotationArguments.kt b/compiler/testData/diagnostics/tests/classLiteral/inAnnotationArguments.kt index 7bb6e4c4ecd..9b7c48d2870 100644 --- a/compiler/testData/diagnostics/tests/classLiteral/inAnnotationArguments.kt +++ b/compiler/testData/diagnostics/tests/classLiteral/inAnnotationArguments.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !LANGUAGE: +ProhibitTypeParametersInClassLiteralsInAnnotationArguments diff --git a/compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotation.fir.kt b/compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotation.fir.kt index 7f72e048a44..0bc708bf99d 100644 --- a/compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotation.fir.kt +++ b/compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotation.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE annotation class Foo(val a: IntArray, val b: Array, val c: FloatArray) @Foo([1], ["/"], [1f]) diff --git a/compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotation.kt b/compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotation.kt index d4736a8b08c..39c237f365d 100644 --- a/compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotation.kt +++ b/compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotation.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE annotation class Foo(val a: IntArray, val b: Array, val c: FloatArray) @Foo([1], ["/"], [1f]) diff --git a/compiler/testData/diagnostics/tests/constructorConsistency/backing.fir.kt b/compiler/testData/diagnostics/tests/constructorConsistency/backing.fir.kt index 57e7fa3c18a..bb90d2a6151 100644 --- a/compiler/testData/diagnostics/tests/constructorConsistency/backing.fir.kt +++ b/compiler/testData/diagnostics/tests/constructorConsistency/backing.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class My { var x = 1 set(value) { diff --git a/compiler/testData/diagnostics/tests/constructorConsistency/backing.kt b/compiler/testData/diagnostics/tests/constructorConsistency/backing.kt index 5104d0fe633..7e4b30e2ce9 100644 --- a/compiler/testData/diagnostics/tests/constructorConsistency/backing.kt +++ b/compiler/testData/diagnostics/tests/constructorConsistency/backing.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class My { var x = 1 set(value) { diff --git a/compiler/testData/diagnostics/tests/constructorConsistency/basic.fir.kt b/compiler/testData/diagnostics/tests/constructorConsistency/basic.fir.kt index 48bfe299b62..a3723ed6b86 100644 --- a/compiler/testData/diagnostics/tests/constructorConsistency/basic.fir.kt +++ b/compiler/testData/diagnostics/tests/constructorConsistency/basic.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class My { val x: String diff --git a/compiler/testData/diagnostics/tests/constructorConsistency/basic.kt b/compiler/testData/diagnostics/tests/constructorConsistency/basic.kt index 3604dc9041c..b09c59a377d 100644 --- a/compiler/testData/diagnostics/tests/constructorConsistency/basic.kt +++ b/compiler/testData/diagnostics/tests/constructorConsistency/basic.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class My { val x: String diff --git a/compiler/testData/diagnostics/tests/constructorConsistency/derivedProperty.fir.kt b/compiler/testData/diagnostics/tests/constructorConsistency/derivedProperty.fir.kt index be7f6b0fc58..2f152e17ec5 100644 --- a/compiler/testData/diagnostics/tests/constructorConsistency/derivedProperty.fir.kt +++ b/compiler/testData/diagnostics/tests/constructorConsistency/derivedProperty.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE interface Base { val x: Int } diff --git a/compiler/testData/diagnostics/tests/constructorConsistency/derivedProperty.kt b/compiler/testData/diagnostics/tests/constructorConsistency/derivedProperty.kt index ad5f9d89b89..c47c4ad448e 100644 --- a/compiler/testData/diagnostics/tests/constructorConsistency/derivedProperty.kt +++ b/compiler/testData/diagnostics/tests/constructorConsistency/derivedProperty.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE interface Base { val x: Int } diff --git a/compiler/testData/diagnostics/tests/constructorConsistency/getset.fir.kt b/compiler/testData/diagnostics/tests/constructorConsistency/getset.fir.kt index 49468747f35..f41ba5a63b9 100644 --- a/compiler/testData/diagnostics/tests/constructorConsistency/getset.fir.kt +++ b/compiler/testData/diagnostics/tests/constructorConsistency/getset.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class My(var x: String) { var y: String diff --git a/compiler/testData/diagnostics/tests/constructorConsistency/getset.kt b/compiler/testData/diagnostics/tests/constructorConsistency/getset.kt index 609c67029fb..dc459d53d46 100644 --- a/compiler/testData/diagnostics/tests/constructorConsistency/getset.kt +++ b/compiler/testData/diagnostics/tests/constructorConsistency/getset.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class My(var x: String) { var y: String diff --git a/compiler/testData/diagnostics/tests/constructorConsistency/init.fir.kt b/compiler/testData/diagnostics/tests/constructorConsistency/init.fir.kt index e64714ea474..84f27db5ae9 100644 --- a/compiler/testData/diagnostics/tests/constructorConsistency/init.fir.kt +++ b/compiler/testData/diagnostics/tests/constructorConsistency/init.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class My { val x: String diff --git a/compiler/testData/diagnostics/tests/constructorConsistency/init.kt b/compiler/testData/diagnostics/tests/constructorConsistency/init.kt index 11115d5449f..e556ca0a686 100644 --- a/compiler/testData/diagnostics/tests/constructorConsistency/init.kt +++ b/compiler/testData/diagnostics/tests/constructorConsistency/init.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class My { val x: String diff --git a/compiler/testData/diagnostics/tests/constructorConsistency/initializerWithSecondaryConstructor.kt b/compiler/testData/diagnostics/tests/constructorConsistency/initializerWithSecondaryConstructor.kt index f573b5143bd..400ec552db7 100644 --- a/compiler/testData/diagnostics/tests/constructorConsistency/initializerWithSecondaryConstructor.kt +++ b/compiler/testData/diagnostics/tests/constructorConsistency/initializerWithSecondaryConstructor.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL private const val A = 0L diff --git a/compiler/testData/diagnostics/tests/constructorConsistency/initwithgetter.fir.kt b/compiler/testData/diagnostics/tests/constructorConsistency/initwithgetter.fir.kt index 87577c486b1..51e60858a01 100644 --- a/compiler/testData/diagnostics/tests/constructorConsistency/initwithgetter.fir.kt +++ b/compiler/testData/diagnostics/tests/constructorConsistency/initwithgetter.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class My { val x: Int get() = field + if (z != "") 1 else 0 diff --git a/compiler/testData/diagnostics/tests/constructorConsistency/initwithgetter.kt b/compiler/testData/diagnostics/tests/constructorConsistency/initwithgetter.kt index c8cf0307f2c..5d82428266e 100644 --- a/compiler/testData/diagnostics/tests/constructorConsistency/initwithgetter.kt +++ b/compiler/testData/diagnostics/tests/constructorConsistency/initwithgetter.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class My { val x: Int get() = field + if (z != "") 1 else 0 diff --git a/compiler/testData/diagnostics/tests/constructorConsistency/inspection.fir.kt b/compiler/testData/diagnostics/tests/constructorConsistency/inspection.fir.kt index deb9cb25b2b..24809d5e1e7 100644 --- a/compiler/testData/diagnostics/tests/constructorConsistency/inspection.fir.kt +++ b/compiler/testData/diagnostics/tests/constructorConsistency/inspection.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class First { val x: String diff --git a/compiler/testData/diagnostics/tests/constructorConsistency/inspection.kt b/compiler/testData/diagnostics/tests/constructorConsistency/inspection.kt index 91c74f34021..9c0760bba25 100644 --- a/compiler/testData/diagnostics/tests/constructorConsistency/inspection.kt +++ b/compiler/testData/diagnostics/tests/constructorConsistency/inspection.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class First { val x: String diff --git a/compiler/testData/diagnostics/tests/constructorConsistency/lateInit.kt b/compiler/testData/diagnostics/tests/constructorConsistency/lateInit.kt index 763dd18d82c..b39128fd8e8 100644 --- a/compiler/testData/diagnostics/tests/constructorConsistency/lateInit.kt +++ b/compiler/testData/diagnostics/tests/constructorConsistency/lateInit.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL class WithLateInit { lateinit var x: String diff --git a/compiler/testData/diagnostics/tests/constructorConsistency/nobacking.kt b/compiler/testData/diagnostics/tests/constructorConsistency/nobacking.kt index f52e83040f8..d92a5909a7c 100644 --- a/compiler/testData/diagnostics/tests/constructorConsistency/nobacking.kt +++ b/compiler/testData/diagnostics/tests/constructorConsistency/nobacking.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL class My { diff --git a/compiler/testData/diagnostics/tests/constructorConsistency/open.fir.kt b/compiler/testData/diagnostics/tests/constructorConsistency/open.fir.kt index 2917319c9ad..a208d1f5040 100644 --- a/compiler/testData/diagnostics/tests/constructorConsistency/open.fir.kt +++ b/compiler/testData/diagnostics/tests/constructorConsistency/open.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE open class Base { init { register(this) diff --git a/compiler/testData/diagnostics/tests/constructorConsistency/open.kt b/compiler/testData/diagnostics/tests/constructorConsistency/open.kt index 355dfca1cce..f23c2d2b262 100644 --- a/compiler/testData/diagnostics/tests/constructorConsistency/open.kt +++ b/compiler/testData/diagnostics/tests/constructorConsistency/open.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE open class Base { init { register(this) diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedOrReassignedVariables.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedOrReassignedVariables.fir.kt index 07863a93c87..232558ad853 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedOrReassignedVariables.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedOrReassignedVariables.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE package uninitialized_reassigned_variables fun doSmth(s: String) {} diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedOrReassignedVariables.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedOrReassignedVariables.kt index 6fa04389dc2..766549c6191 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedOrReassignedVariables.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedOrReassignedVariables.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE package uninitialized_reassigned_variables fun doSmth(s: String) {} diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/assignmentInLocalsInConstructor.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/assignmentInLocalsInConstructor.fir.kt index cb930b76e58..cddb72e2490 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/assignmentInLocalsInConstructor.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/assignmentInLocalsInConstructor.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // Tests for KT-13597 (val assignment inside local object in constructor) class Test { diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/assignmentInLocalsInConstructor.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/assignmentInLocalsInConstructor.kt index 572fa3a5893..8a09fd2ba00 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/assignmentInLocalsInConstructor.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/assignmentInLocalsInConstructor.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // Tests for KT-13597 (val assignment inside local object in constructor) class Test { diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/capturingUninitializedVariableInNonInPlaceLambda.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/capturingUninitializedVariableInNonInPlaceLambda.fir.kt index ddcf0912129..aade73b7461 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/capturingUninitializedVariableInNonInPlaceLambda.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/capturingUninitializedVariableInNonInPlaceLambda.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // DIAGNOSTICS: -UNUSED_PARAMETER // WITH_STDLIB diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/capturingUninitializedVariableInNonInPlaceLambda.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/capturingUninitializedVariableInNonInPlaceLambda.kt index dca37563d4f..293004f9c65 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/capturingUninitializedVariableInNonInPlaceLambda.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/capturingUninitializedVariableInNonInPlaceLambda.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // DIAGNOSTICS: -UNUSED_PARAMETER // WITH_STDLIB diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/delegatedMemberProperyWriteInInit.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/delegatedMemberProperyWriteInInit.fir.kt index 93254ac730c..abd6d90be2d 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/delegatedMemberProperyWriteInInit.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/delegatedMemberProperyWriteInInit.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // DIAGNOSTICS: -UNUSED_PARAMETER import kotlin.reflect.KProperty diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/delegatedMemberProperyWriteInInit.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/delegatedMemberProperyWriteInInit.kt index 528e77657ed..8af48709c7f 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/delegatedMemberProperyWriteInInit.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/delegatedMemberProperyWriteInInit.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // DIAGNOSTICS: -UNUSED_PARAMETER import kotlin.reflect.KProperty diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/delegatedPropertyEarlyAccess.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/delegatedPropertyEarlyAccess.fir.kt index c9b2fd3f520..73bfc1ed07d 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/delegatedPropertyEarlyAccess.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/delegatedPropertyEarlyAccess.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // ISSUE: KT-10869, KT-56682 import kotlin.reflect.KProperty diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/delegatedPropertyEarlyAccess.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/delegatedPropertyEarlyAccess.kt index b8ff9cb0e32..19205467855 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/delegatedPropertyEarlyAccess.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/delegatedPropertyEarlyAccess.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // ISSUE: KT-10869, KT-56682 import kotlin.reflect.KProperty diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldAsClassDelegate.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldAsClassDelegate.fir.kt index 2a0bfcee7ae..db7c2aaa257 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldAsClassDelegate.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldAsClassDelegate.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // See KT-15566 // NI_EXPECTED_FILE diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldAsClassDelegate.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldAsClassDelegate.kt index a2c58cd474c..22594dd5cdc 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldAsClassDelegate.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldAsClassDelegate.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // See KT-15566 // NI_EXPECTED_FILE diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldInitialization.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldInitialization.fir.kt index 2efb4954808..71d718b89e1 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldInitialization.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldInitialization.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: +AllowContractsForCustomFunctions +UseCallsInPlaceEffect // !OPT_IN: kotlin.internal.ContractsDsl diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldInitialization.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldInitialization.kt index 9038dcaa5ba..6d21d86c6d9 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldInitialization.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldInitialization.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: +AllowContractsForCustomFunctions +UseCallsInPlaceEffect // !OPT_IN: kotlin.internal.ContractsDsl diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLambda.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLambda.fir.kt index 574f6088f64..7b91f0fa27b 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLambda.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLambda.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE fun ignoreIt(f: () -> Unit) {} diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLambda.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLambda.kt index 324128fc16e..0b92a5c2b60 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLambda.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLambda.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE fun ignoreIt(f: () -> Unit) {} diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalClass.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalClass.fir.kt index 906cb88415d..effeef8c427 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalClass.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalClass.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE fun foo() { diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalClass.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalClass.kt index 4f93a22cb82..55237899f4b 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalClass.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalClass.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE fun foo() { diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalViaExplicitThis_after.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalViaExplicitThis_after.fir.kt index 92bc609ce34..10a0e76598d 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalViaExplicitThis_after.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalViaExplicitThis_after.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: +ReadDeserializedContracts +UseCallsInPlaceEffect // See KT-17479 diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalViaExplicitThis_after.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalViaExplicitThis_after.kt index fea2541eafd..85b12263a45 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalViaExplicitThis_after.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalViaExplicitThis_after.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: +ReadDeserializedContracts +UseCallsInPlaceEffect // See KT-17479 diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalViaExplicitThis_before.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalViaExplicitThis_before.fir.kt index 11fbf5ef942..9dd23bc8cbf 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalViaExplicitThis_before.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalViaExplicitThis_before.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ReadDeserializedContracts -UseCallsInPlaceEffect // See KT-17479 diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalViaExplicitThis_before.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalViaExplicitThis_before.kt index 6c07c4ba357..b6ea87757ff 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalViaExplicitThis_before.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalViaExplicitThis_before.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ReadDeserializedContracts -UseCallsInPlaceEffect // See KT-17479 diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2330.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2330.fir.kt index 62566e25c37..8b57efec51f 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2330.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2330.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE //KT-2330 Check visibility of getters and setters correspondingly package a diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2330.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2330.kt index bee0f36395b..e113f49d8c6 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2330.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2330.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE //KT-2330 Check visibility of getters and setters correspondingly package a diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt4405.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt4405.fir.kt index 773c6d2846a..b3766df5ee0 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt4405.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt4405.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE //KT-4405 Control-flow analysis is not performed for some local declarations package d diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt4405.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt4405.kt index aa75386d3a1..edc20d61f77 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt4405.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt4405.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE //KT-4405 Control-flow analysis is not performed for some local declarations package d diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt510.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt510.kt index 3faf5dc59ba..4b3f51df168 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt510.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt510.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL //KT-510 `this.` allows initialization without backing field diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt6788.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt6788.fir.kt index c946e9037da..141373db317 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt6788.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt6788.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class A(val next: A? = null) { val x: String init { diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt6788.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt6788.kt index 1adb2ece935..d3b5262865b 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt6788.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt6788.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class A(val next: A? = null) { val x: String init { diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt897.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt897.kt index 0f56423a5a9..6110f119bc4 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt897.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt897.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL //KT-897 Don't allow assignment to a property before it is defined diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstance.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstance.fir.kt index bc4d852b749..440912acf0d 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstance.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstance.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class A(val next: A? = null) { val x: String init { diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstance.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstance.kt index ae1af050d7b..d2329d697cc 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstance.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstance.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class A(val next: A? = null) { val x: String init { diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstanceInner.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstanceInner.fir.kt index 3b2cdaae39e..bb1155eeeea 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstanceInner.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstanceInner.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class Outer { val outerProp: String inner class Inner(inner: Inner, outer: Outer) { diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstanceInner.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstanceInner.kt index ee36d864d8e..a71d48ac70b 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstanceInner.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstanceInner.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class Outer { val outerProp: String inner class Inner(inner: Inner, outer: Outer) { diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstanceThisLabel.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstanceThisLabel.fir.kt index 8c2b51fa08b..c74dff0fe81 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstanceThisLabel.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstanceThisLabel.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class A(val next: A? = null) { val x: String init { diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstanceThisLabel.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstanceThisLabel.kt index c07023a0852..ffd0ed81eea 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstanceThisLabel.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstanceThisLabel.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class A(val next: A? = null) { val x: String init { diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/referenceToPropertyInitializer.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/referenceToPropertyInitializer.fir.kt index 07b6585530b..e7da4b4cebb 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/referenceToPropertyInitializer.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/referenceToPropertyInitializer.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_VARIABLE package o diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/referenceToPropertyInitializer.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/referenceToPropertyInitializer.kt index 4e8bca9bdf7..819ccec6601 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/referenceToPropertyInitializer.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/referenceToPropertyInitializer.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_VARIABLE package o diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/repeatUnitializedErrorOnlyForLocalVars.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/repeatUnitializedErrorOnlyForLocalVars.fir.kt index be28e872c2e..56f92016cb2 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/repeatUnitializedErrorOnlyForLocalVars.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/repeatUnitializedErrorOnlyForLocalVars.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE package aa val a : Int = b diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/repeatUnitializedErrorOnlyForLocalVars.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/repeatUnitializedErrorOnlyForLocalVars.kt index 974b04c2d6f..b16b4200522 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/repeatUnitializedErrorOnlyForLocalVars.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/repeatUnitializedErrorOnlyForLocalVars.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE package aa val a : Int = b diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/scopeOfAnonymousInitializer.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/scopeOfAnonymousInitializer.kt index 4b0a549c1dc..78d1f53fa29 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/scopeOfAnonymousInitializer.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/scopeOfAnonymousInitializer.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL class AnonymousInitializers(var a: String) { init { diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/uninintializedProperyWithDirectAndDelayedInitialization.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/uninintializedProperyWithDirectAndDelayedInitialization.kt index f5588762ddf..e1061ccafb0 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/uninintializedProperyWithDirectAndDelayedInitialization.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/uninintializedProperyWithDirectAndDelayedInitialization.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // ISSUE: KT-56678 diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/uninitializedQualifiedEnumEntry.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/uninitializedQualifiedEnumEntry.kt index 440ba0bc4bb..7f90fab1277 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/uninitializedQualifiedEnumEntry.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/uninitializedQualifiedEnumEntry.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // LANGUAGE: +ProhibitQualifiedAccessToUninitializedEnumEntry // ISSUE: KT-41124 diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitRecursiveInLambda.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitRecursiveInLambda.fir.kt index 672cb34beb4..bf206d27bb7 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitRecursiveInLambda.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitRecursiveInLambda.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class Test { lateinit var someRunnable: Runnable init { diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitRecursiveInLambda.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitRecursiveInLambda.kt index 718684da9b5..626f834ea90 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitRecursiveInLambda.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitRecursiveInLambda.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class Test { lateinit var someRunnable: Runnable init { diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithInit.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithInit.kt index e4a4d6e95c2..442aa45866a 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithInit.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithInit.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL class Foo { lateinit var bar: String diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithMultipleConstructorsAndDelegation.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithMultipleConstructorsAndDelegation.kt index f9f31de7f0e..3a0ddc647be 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithMultipleConstructorsAndDelegation.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithMultipleConstructorsAndDelegation.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_PARAMETER diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithPrimaryConstructorAndConstructor.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithPrimaryConstructorAndConstructor.kt index 787c34ea219..adf7bf066fe 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithPrimaryConstructorAndConstructor.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithPrimaryConstructorAndConstructor.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_PARAMETER diff --git a/compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaKotlinCycle.fir.kt b/compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaKotlinCycle.fir.kt index c56c6f3492f..165a6b0e16f 100644 --- a/compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaKotlinCycle.fir.kt +++ b/compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaKotlinCycle.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FILE: I.kt open class I : K() { diff --git a/compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaKotlinCycle.kt b/compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaKotlinCycle.kt index 1df66a7bd15..24e97f83e97 100644 --- a/compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaKotlinCycle.kt +++ b/compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaKotlinCycle.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FILE: I.kt open class I : K() { diff --git a/compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaKotlinCycle.ll.kt b/compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaKotlinCycle.ll.kt index 56ba19ed783..ba8326c24d3 100644 --- a/compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaKotlinCycle.ll.kt +++ b/compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaKotlinCycle.ll.kt @@ -1,7 +1,7 @@ // LL_FIR_DIVERGENCE // The compiler doesn't guarantee exhaustiveness in reporting of inheritance cycles, so the compiler and LL FIR results are equally valid. // LL_FIR_DIVERGENCE - +// IGNORE_REVERSED_RESOLVE // FILE: I.kt open class I : K() { diff --git a/compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaNestedCycle.fir.kt b/compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaNestedCycle.fir.kt index 208e0735310..663f78ed117 100644 --- a/compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaNestedCycle.fir.kt +++ b/compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaNestedCycle.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FILE: ExceptionTracker.kt interface ExceptionTracker : LockBasedStorageManager.ExceptionHandlingStrategy { diff --git a/compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaNestedCycle.kt b/compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaNestedCycle.kt index 1edd2e30e6d..7d341522483 100644 --- a/compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaNestedCycle.kt +++ b/compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaNestedCycle.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FILE: ExceptionTracker.kt interface ExceptionTracker : LockBasedStorageManager.ExceptionHandlingStrategy { diff --git a/compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.fir.kt b/compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.fir.kt index b5dba09b804..ccdb9bd54ec 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.fir.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE interface Lazy { operator fun getValue(a1: Any, a2: Any): T } diff --git a/compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.kt b/compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.kt index e02c8f6d41f..12d7c36f058 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE interface Lazy { operator fun getValue(a1: Any, a2: Any): T } diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.fir.kt index 0ca79449c41..be7e772f445 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.fir.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_PARAMETER // NI_EXPECTED_FILE diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.kt b/compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.kt index a85581e4f19..870c51aaa54 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_PARAMETER // NI_EXPECTED_FILE diff --git a/compiler/testData/diagnostics/tests/delegation/kt49477.fir.kt b/compiler/testData/diagnostics/tests/delegation/kt49477.fir.kt index 45014c3ecde..990bb273b76 100644 --- a/compiler/testData/diagnostics/tests/delegation/kt49477.fir.kt +++ b/compiler/testData/diagnostics/tests/delegation/kt49477.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // WITH_STDLIB import kotlin.properties.ReadWriteProperty diff --git a/compiler/testData/diagnostics/tests/delegation/kt49477.kt b/compiler/testData/diagnostics/tests/delegation/kt49477.kt index 2efb3cc60fd..b7778d18b5d 100644 --- a/compiler/testData/diagnostics/tests/delegation/kt49477.kt +++ b/compiler/testData/diagnostics/tests/delegation/kt49477.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // WITH_STDLIB import kotlin.properties.ReadWriteProperty diff --git a/compiler/testData/diagnostics/tests/delegation/kt49477Error.fir.kt b/compiler/testData/diagnostics/tests/delegation/kt49477Error.fir.kt index e99e8bdb576..bcc6246dd1d 100644 --- a/compiler/testData/diagnostics/tests/delegation/kt49477Error.fir.kt +++ b/compiler/testData/diagnostics/tests/delegation/kt49477Error.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: +ForbidRecursiveDelegateExpressions // WITH_STDLIB diff --git a/compiler/testData/diagnostics/tests/delegation/kt49477Error.kt b/compiler/testData/diagnostics/tests/delegation/kt49477Error.kt index e51ea6d7b9e..a0086fccd19 100644 --- a/compiler/testData/diagnostics/tests/delegation/kt49477Error.kt +++ b/compiler/testData/diagnostics/tests/delegation/kt49477Error.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: +ForbidRecursiveDelegateExpressions // WITH_STDLIB diff --git a/compiler/testData/diagnostics/tests/exposed/protected.fir.kt b/compiler/testData/diagnostics/tests/exposed/protected.fir.kt index ceeb5c42e65..4d3c802d379 100644 --- a/compiler/testData/diagnostics/tests/exposed/protected.fir.kt +++ b/compiler/testData/diagnostics/tests/exposed/protected.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE open class A { // protected relative to A protected open class B { diff --git a/compiler/testData/diagnostics/tests/exposed/protected.kt b/compiler/testData/diagnostics/tests/exposed/protected.kt index 8c8b81c6504..40100d5351c 100644 --- a/compiler/testData/diagnostics/tests/exposed/protected.kt +++ b/compiler/testData/diagnostics/tests/exposed/protected.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE open class A { // protected relative to A protected open class B { diff --git a/compiler/testData/diagnostics/tests/extensions/variableInvoke.fir.kt b/compiler/testData/diagnostics/tests/extensions/variableInvoke.fir.kt index a940855855a..de8c810de5d 100644 --- a/compiler/testData/diagnostics/tests/extensions/variableInvoke.fir.kt +++ b/compiler/testData/diagnostics/tests/extensions/variableInvoke.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class A(foo: Int.() -> Unit) { init { 4.foo() diff --git a/compiler/testData/diagnostics/tests/extensions/variableInvoke.kt b/compiler/testData/diagnostics/tests/extensions/variableInvoke.kt index 837a7d3814e..e284e75b780 100644 --- a/compiler/testData/diagnostics/tests/extensions/variableInvoke.kt +++ b/compiler/testData/diagnostics/tests/extensions/variableInvoke.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class A(foo: Int.() -> Unit) { init { 4.foo() diff --git a/compiler/testData/diagnostics/tests/functionAsExpression/WithOuterGeneric.kt b/compiler/testData/diagnostics/tests/functionAsExpression/WithOuterGeneric.kt index ba697918aab..f987bf7a35a 100644 --- a/compiler/testData/diagnostics/tests/functionAsExpression/WithOuterGeneric.kt +++ b/compiler/testData/diagnostics/tests/functionAsExpression/WithOuterGeneric.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE diff --git a/compiler/testData/diagnostics/tests/generics/innerClasses/kt3357.kt b/compiler/testData/diagnostics/tests/generics/innerClasses/kt3357.kt index e7ec070e349..a69734ef1e4 100644 --- a/compiler/testData/diagnostics/tests/generics/innerClasses/kt3357.kt +++ b/compiler/testData/diagnostics/tests/generics/innerClasses/kt3357.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_VARIABLE diff --git a/compiler/testData/diagnostics/tests/implicitNothing.fir.kt b/compiler/testData/diagnostics/tests/implicitNothing.fir.kt index a6c2bd1fcb4..4c76d90ba9f 100644 --- a/compiler/testData/diagnostics/tests/implicitNothing.fir.kt +++ b/compiler/testData/diagnostics/tests/implicitNothing.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE fun foo() = throw Exception() fun bar() = null!! diff --git a/compiler/testData/diagnostics/tests/implicitNothing.kt b/compiler/testData/diagnostics/tests/implicitNothing.kt index adb0a7cc7f4..54a43e18988 100644 --- a/compiler/testData/diagnostics/tests/implicitNothing.kt +++ b/compiler/testData/diagnostics/tests/implicitNothing.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE fun foo() = throw Exception() fun bar() = null!! diff --git a/compiler/testData/diagnostics/tests/inference/constraints/definitelyNotNullTypeInReturnPosition.fir.kt b/compiler/testData/diagnostics/tests/inference/constraints/definitelyNotNullTypeInReturnPosition.fir.kt index 7c03187069e..fcc3a81dca9 100644 --- a/compiler/testData/diagnostics/tests/inference/constraints/definitelyNotNullTypeInReturnPosition.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/constraints/definitelyNotNullTypeInReturnPosition.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_EXPRESSION -CAST_NEVER_SUCCEEDS -UNUSED_VARIABLE -UNCHECKED_CAST class Foo(x: T) diff --git a/compiler/testData/diagnostics/tests/inference/constraints/definitelyNotNullTypeInReturnPosition.kt b/compiler/testData/diagnostics/tests/inference/constraints/definitelyNotNullTypeInReturnPosition.kt index ebeb5ba9d8b..867c1e62d81 100644 --- a/compiler/testData/diagnostics/tests/inference/constraints/definitelyNotNullTypeInReturnPosition.kt +++ b/compiler/testData/diagnostics/tests/inference/constraints/definitelyNotNullTypeInReturnPosition.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_EXPRESSION -CAST_NEVER_SUCCEEDS -UNUSED_VARIABLE -UNCHECKED_CAST class Foo(x: T) diff --git a/compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt48935.diag.txt b/compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt48935.diag.txt index cd9d8450834..3aeb28cc279 100644 --- a/compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt48935.diag.txt +++ b/compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt48935.diag.txt @@ -1,7 +1,7 @@ -/kt48935.kt:7:35: warning: parameter 'func' is never used +/kt48935.kt:8:35: warning: parameter 'func' is never used fun exampleGenericFunction(func: V) where T: Base, V: (T) -> Unit { ^ -/kt48935.kt:13:5: warning: type argument for a type parameter T has possible incompatible upper bounds: Base, DoesNotImplementBase (final class and interface) +/kt48935.kt:14:5: warning: type argument for a type parameter T has possible incompatible upper bounds: Base, DoesNotImplementBase (final class and interface) exampleGenericFunction(func) // expected this to be a compilation error as the T: Base constraint should not be satisfied ^ diff --git a/compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt48935.kt b/compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt48935.kt index 0ffc1386ffa..2f8cae74175 100644 --- a/compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt48935.kt +++ b/compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt48935.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // RENDER_DIAGNOSTICS_FULL_TEXT interface Base diff --git a/compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt48935_5.kt b/compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt48935_5.kt index f8e93eac92f..355c4312f19 100644 --- a/compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt48935_5.kt +++ b/compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt48935_5.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL interface Base diff --git a/compiler/testData/diagnostics/tests/inference/recursiveCalls/kt23531.fir.kt b/compiler/testData/diagnostics/tests/inference/recursiveCalls/kt23531.fir.kt index 68c66797f5d..304c0b457ed 100644 --- a/compiler/testData/diagnostics/tests/inference/recursiveCalls/kt23531.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/recursiveCalls/kt23531.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_PARAMETER class Scope diff --git a/compiler/testData/diagnostics/tests/inference/recursiveCalls/kt23531.kt b/compiler/testData/diagnostics/tests/inference/recursiveCalls/kt23531.kt index 12d5f370ad2..e5fb4a2f48a 100644 --- a/compiler/testData/diagnostics/tests/inference/recursiveCalls/kt23531.kt +++ b/compiler/testData/diagnostics/tests/inference/recursiveCalls/kt23531.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_PARAMETER class Scope diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt41386.fir.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt41386.fir.kt index 98e45b910e9..28e083c2627 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt41386.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt41386.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE open class Test(val map1 : Map, val map2 : Map) { open val inverse: Test = object : Test(map2, map1) { diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt41386.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt41386.kt index 7f7baabd4a1..0565f8aef72 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt41386.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt41386.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE open class Test(val map1 : Map, val map2 : Map) { open val inverse: Test = object : Test(map2, map1) { diff --git a/compiler/testData/diagnostics/tests/inference/substitutions/delegationAndInference.kt b/compiler/testData/diagnostics/tests/inference/substitutions/delegationAndInference.kt index b045e9809e0..40e17302536 100644 --- a/compiler/testData/diagnostics/tests/inference/substitutions/delegationAndInference.kt +++ b/compiler/testData/diagnostics/tests/inference/substitutions/delegationAndInference.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_PARAMETER diff --git a/compiler/testData/diagnostics/tests/inference/typeParameterInConstructor.kt b/compiler/testData/diagnostics/tests/inference/typeParameterInConstructor.kt index f1424b0d01a..46c3e755331 100644 --- a/compiler/testData/diagnostics/tests/inference/typeParameterInConstructor.kt +++ b/compiler/testData/diagnostics/tests/inference/typeParameterInConstructor.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL class B(val obj: O) { diff --git a/compiler/testData/diagnostics/tests/infos/PropertiesWithBackingFields.kt b/compiler/testData/diagnostics/tests/infos/PropertiesWithBackingFields.kt index 44fe3532bf5..bc62f493a1e 100644 --- a/compiler/testData/diagnostics/tests/infos/PropertiesWithBackingFields.kt +++ b/compiler/testData/diagnostics/tests/infos/PropertiesWithBackingFields.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL abstract class Test() { abstract val x : Int diff --git a/compiler/testData/diagnostics/tests/initializedAfterRethrow.fir.kt b/compiler/testData/diagnostics/tests/initializedAfterRethrow.fir.kt index 1bfc432da32..609b1267d8c 100644 --- a/compiler/testData/diagnostics/tests/initializedAfterRethrow.fir.kt +++ b/compiler/testData/diagnostics/tests/initializedAfterRethrow.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE fun foo(): Int = 42 diff --git a/compiler/testData/diagnostics/tests/initializedAfterRethrow.kt b/compiler/testData/diagnostics/tests/initializedAfterRethrow.kt index f4897417874..3dd67c50012 100644 --- a/compiler/testData/diagnostics/tests/initializedAfterRethrow.kt +++ b/compiler/testData/diagnostics/tests/initializedAfterRethrow.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE fun foo(): Int = 42 diff --git a/compiler/testData/diagnostics/tests/inlineClasses/presenceOfInitializerBlockInsideInlineClass.kt b/compiler/testData/diagnostics/tests/inlineClasses/presenceOfInitializerBlockInsideInlineClass.kt index b02d8a15901..02709704dd0 100644 --- a/compiler/testData/diagnostics/tests/inlineClasses/presenceOfInitializerBlockInsideInlineClass.kt +++ b/compiler/testData/diagnostics/tests/inlineClasses/presenceOfInitializerBlockInsideInlineClass.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !LANGUAGE: +InlineClasses, -JvmInlineValueClasses // !DIAGNOSTICS: -UNUSED_VARIABLE diff --git a/compiler/testData/diagnostics/tests/j+k/primitiveOverridesWithInlineClass/inlineClassErasedToPrimitiveInt.kt b/compiler/testData/diagnostics/tests/j+k/primitiveOverridesWithInlineClass/inlineClassErasedToPrimitiveInt.kt index deff956d8f8..d9931a05b92 100644 --- a/compiler/testData/diagnostics/tests/j+k/primitiveOverridesWithInlineClass/inlineClassErasedToPrimitiveInt.kt +++ b/compiler/testData/diagnostics/tests/j+k/primitiveOverridesWithInlineClass/inlineClassErasedToPrimitiveInt.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !LANGUAGE: +InlineClasses, -JvmInlineValueClasses // FILE: kt1.kt diff --git a/compiler/testData/diagnostics/tests/j+k/properties/interface.kt b/compiler/testData/diagnostics/tests/j+k/properties/interface.kt index 86a21f55bb0..758a4b5dc08 100644 --- a/compiler/testData/diagnostics/tests/j+k/properties/interface.kt +++ b/compiler/testData/diagnostics/tests/j+k/properties/interface.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // FILE: A.java diff --git a/compiler/testData/diagnostics/tests/j+k/syntheticPropertyOverridden2.fir.kt b/compiler/testData/diagnostics/tests/j+k/syntheticPropertyOverridden2.fir.kt index bcaf683633d..dc52330bc7d 100644 --- a/compiler/testData/diagnostics/tests/j+k/syntheticPropertyOverridden2.fir.kt +++ b/compiler/testData/diagnostics/tests/j+k/syntheticPropertyOverridden2.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // ISSUE: KT-57166 // FILE: Modality.kt diff --git a/compiler/testData/diagnostics/tests/j+k/syntheticPropertyOverridden2.kt b/compiler/testData/diagnostics/tests/j+k/syntheticPropertyOverridden2.kt index 1655a63b08a..fd9693c30b3 100644 --- a/compiler/testData/diagnostics/tests/j+k/syntheticPropertyOverridden2.kt +++ b/compiler/testData/diagnostics/tests/j+k/syntheticPropertyOverridden2.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // ISSUE: KT-57166 // FILE: Modality.kt diff --git a/compiler/testData/diagnostics/tests/kt46483.fir.kt b/compiler/testData/diagnostics/tests/kt46483.fir.kt index 57e6f327681..a68e7ec9c7d 100644 --- a/compiler/testData/diagnostics/tests/kt46483.fir.kt +++ b/compiler/testData/diagnostics/tests/kt46483.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE @Repeatable @Target( AnnotationTarget.TYPE_PARAMETER) annotation class TypeParameterAnn(val name: String) diff --git a/compiler/testData/diagnostics/tests/kt46483.kt b/compiler/testData/diagnostics/tests/kt46483.kt index 1e8b5a07149..1d3ef4ef8b5 100644 --- a/compiler/testData/diagnostics/tests/kt46483.kt +++ b/compiler/testData/diagnostics/tests/kt46483.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE @Repeatable @Target( AnnotationTarget.TYPE_PARAMETER) annotation class TypeParameterAnn(val name: String) diff --git a/compiler/testData/diagnostics/tests/lateinit/modifierApplicability_lv12.fir.kt b/compiler/testData/diagnostics/tests/lateinit/modifierApplicability_lv12.fir.kt index df4efef4a49..21d36c02c24 100644 --- a/compiler/testData/diagnostics/tests/lateinit/modifierApplicability_lv12.fir.kt +++ b/compiler/testData/diagnostics/tests/lateinit/modifierApplicability_lv12.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: +LateinitTopLevelProperties +LateinitLocalVariables import kotlin.reflect.KProperty diff --git a/compiler/testData/diagnostics/tests/lateinit/modifierApplicability_lv12.kt b/compiler/testData/diagnostics/tests/lateinit/modifierApplicability_lv12.kt index 790bb891756..aeb4ced2080 100644 --- a/compiler/testData/diagnostics/tests/lateinit/modifierApplicability_lv12.kt +++ b/compiler/testData/diagnostics/tests/lateinit/modifierApplicability_lv12.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: +LateinitTopLevelProperties +LateinitLocalVariables import kotlin.reflect.KProperty diff --git a/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.fir.kt b/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.fir.kt index d04f1568309..7f4cc994dcd 100644 --- a/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.fir.kt +++ b/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE @myAnnotation public package illegal_modifiers diff --git a/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt b/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt index 6970c7d31cf..7dcf3cea177 100644 --- a/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt +++ b/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE @myAnnotation public package illegal_modifiers diff --git a/compiler/testData/diagnostics/tests/modifiers/const/applicability.fir.kt b/compiler/testData/diagnostics/tests/modifiers/const/applicability.fir.kt index a60ec2adcb9..a6f89a26670 100644 --- a/compiler/testData/diagnostics/tests/modifiers/const/applicability.fir.kt +++ b/compiler/testData/diagnostics/tests/modifiers/const/applicability.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_VARIABLE -CAST_NEVER_SUCCEEDS -DIVISION_BY_ZERO import kotlin.reflect.KProperty diff --git a/compiler/testData/diagnostics/tests/modifiers/const/applicability.kt b/compiler/testData/diagnostics/tests/modifiers/const/applicability.kt index 6b53b8d7874..06e9919d752 100644 --- a/compiler/testData/diagnostics/tests/modifiers/const/applicability.kt +++ b/compiler/testData/diagnostics/tests/modifiers/const/applicability.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_VARIABLE -CAST_NEVER_SUCCEEDS -DIVISION_BY_ZERO import kotlin.reflect.KProperty diff --git a/compiler/testData/diagnostics/tests/modifiers/const/fromJava.fir.kt b/compiler/testData/diagnostics/tests/modifiers/const/fromJava.fir.kt index 34e6e03db52..79b6fd16aff 100644 --- a/compiler/testData/diagnostics/tests/modifiers/const/fromJava.fir.kt +++ b/compiler/testData/diagnostics/tests/modifiers/const/fromJava.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FILE: A.java public class A { diff --git a/compiler/testData/diagnostics/tests/modifiers/const/fromJava.kt b/compiler/testData/diagnostics/tests/modifiers/const/fromJava.kt index 412506e511d..d9279cf04d3 100644 --- a/compiler/testData/diagnostics/tests/modifiers/const/fromJava.kt +++ b/compiler/testData/diagnostics/tests/modifiers/const/fromJava.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FILE: A.java public class A { diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/collectionMethodStub.kt b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/collectionMethodStub.kt index 60c747a0c2d..122fc05ec16 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/collectionMethodStub.kt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/collectionMethodStub.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // SKIP_TXT // FILE: f1.kt diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/headerClassWithFunctionBody.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/headerClassWithFunctionBody.fir.kt index 993e4e8529d..d324bf63af6 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/headerClassWithFunctionBody.fir.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/headerClassWithFunctionBody.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // MODULE: m1-common // FILE: common.kt expect class Foo( diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/headerClassWithFunctionBody.kt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/headerClassWithFunctionBody.kt index f6d046a310e..0ef4f7a64cc 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/headerClassWithFunctionBody.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/headerClassWithFunctionBody.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // MODULE: m1-common // FILE: common.kt expect class Foo( diff --git a/compiler/testData/diagnostics/tests/multiplatform/hmpp/multiplatformCompositeAnalysis/expectAndActualInTheSameModule.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/hmpp/multiplatformCompositeAnalysis/expectAndActualInTheSameModule.fir.kt index 3897b638cfb..35032665242 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/hmpp/multiplatformCompositeAnalysis/expectAndActualInTheSameModule.fir.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/hmpp/multiplatformCompositeAnalysis/expectAndActualInTheSameModule.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // MODULE: common // TARGET_PLATFORM: Common diff --git a/compiler/testData/diagnostics/tests/multiplatform/hmpp/multiplatformCompositeAnalysis/expectAndActualInTheSameModule.kt b/compiler/testData/diagnostics/tests/multiplatform/hmpp/multiplatformCompositeAnalysis/expectAndActualInTheSameModule.kt index 470a2c7a0e2..a7f9a14599e 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/hmpp/multiplatformCompositeAnalysis/expectAndActualInTheSameModule.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/hmpp/multiplatformCompositeAnalysis/expectAndActualInTheSameModule.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // MODULE: common // TARGET_PLATFORM: Common diff --git a/compiler/testData/diagnostics/tests/multiplatform/modifierApplicability.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/modifierApplicability.fir.kt index 7b2f6e72f05..b53c29d7e50 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/modifierApplicability.fir.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/modifierApplicability.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // MODULE: m1-common // FILE: common.kt diff --git a/compiler/testData/diagnostics/tests/multiplatform/modifierApplicability.kt b/compiler/testData/diagnostics/tests/multiplatform/modifierApplicability.kt index 2bb567aa109..57a3de167b7 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/modifierApplicability.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/modifierApplicability.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // MODULE: m1-common // FILE: common.kt diff --git a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt244.fir.kt b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt244.fir.kt index 85372301de9..ced552d2826 100644 --- a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt244.fir.kt +++ b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt244.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE package kt244 diff --git a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt244.kt b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt244.kt index d492e1a1224..f5d3a5a4c4d 100644 --- a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt244.kt +++ b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt244.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE package kt244 diff --git a/compiler/testData/diagnostics/tests/overload/LocalFunctions.fir.kt b/compiler/testData/diagnostics/tests/overload/LocalFunctions.fir.kt index 1e9a89bbffd..419e34d5a7f 100644 --- a/compiler/testData/diagnostics/tests/overload/LocalFunctions.fir.kt +++ b/compiler/testData/diagnostics/tests/overload/LocalFunctions.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE fun test() { fun test1() {} fun test1() {} diff --git a/compiler/testData/diagnostics/tests/overload/LocalFunctions.kt b/compiler/testData/diagnostics/tests/overload/LocalFunctions.kt index 1898fb1c6e0..9f5e3fc7553 100644 --- a/compiler/testData/diagnostics/tests/overload/LocalFunctions.kt +++ b/compiler/testData/diagnostics/tests/overload/LocalFunctions.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE fun test() { fun test1() {} fun test1() {} diff --git a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/interdependentTypeParametersFromKotlin.fir.kt b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/interdependentTypeParametersFromKotlin.fir.kt index e35849f58bf..03dfd2010b5 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/interdependentTypeParametersFromKotlin.fir.kt +++ b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/interdependentTypeParametersFromKotlin.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FILE: Boo.java public class Boo { static Foo test1() { return null; } diff --git a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/interdependentTypeParametersFromKotlin.kt b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/interdependentTypeParametersFromKotlin.kt index 92ab706d78f..2b6e1182cd6 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/interdependentTypeParametersFromKotlin.kt +++ b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/interdependentTypeParametersFromKotlin.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FILE: Boo.java public class Boo { static Foo test1() { return null; } diff --git a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/nonProjectedInnerErasure.kt b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/nonProjectedInnerErasure.kt index 87bba19b3ac..e0de223d22a 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/nonProjectedInnerErasure.kt +++ b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/nonProjectedInnerErasure.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // ISSUE: KT-57198 // FILE: CustomGdbServerRunConfiguration.java diff --git a/compiler/testData/diagnostics/tests/regressions/kt1639-JFrame.kt b/compiler/testData/diagnostics/tests/regressions/kt1639-JFrame.kt index 1496c0556c2..02e831a75b1 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt1639-JFrame.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt1639-JFrame.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // FULL_JDK // SKIP_TXT diff --git a/compiler/testData/diagnostics/tests/regressions/kt3731.kt b/compiler/testData/diagnostics/tests/regressions/kt3731.kt index c2f4cd15ceb..dccc1a18939 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt3731.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt3731.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // KT-3731 Resolve & inner class diff --git a/compiler/testData/diagnostics/tests/regressions/kt575.kt b/compiler/testData/diagnostics/tests/regressions/kt575.kt index 682758bf43e..cd0f0373d40 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt575.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt575.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // KT-575 Cannot ++ a companion object member diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/extensionValueAsNonExtension.kt b/compiler/testData/diagnostics/tests/resolve/invoke/extensionValueAsNonExtension.kt index d7dae292233..3325c18c6bb 100644 --- a/compiler/testData/diagnostics/tests/resolve/invoke/extensionValueAsNonExtension.kt +++ b/compiler/testData/diagnostics/tests/resolve/invoke/extensionValueAsNonExtension.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE class A diff --git a/compiler/testData/diagnostics/tests/scopes/genericVsNested.kt b/compiler/testData/diagnostics/tests/scopes/genericVsNested.kt index 4007db23f92..b76efc968c0 100644 --- a/compiler/testData/diagnostics/tests/scopes/genericVsNested.kt +++ b/compiler/testData/diagnostics/tests/scopes/genericVsNested.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL class A { class T diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/companionObject.fir.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/companionObject.fir.kt index ea8817f6acc..72128fa87b2 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/companionObject.fir.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/companionObject.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion interface A { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/companionObject.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/companionObject.kt index 77148da35ae..af632b308cb 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/companionObject.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/companionObject.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion interface A { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectAfterJava.fir.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectAfterJava.fir.kt index bf33833168b..88a8ac00e57 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectAfterJava.fir.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectAfterJava.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion // FILE: 1.kt diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectAfterJava.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectAfterJava.kt index c23589d5cc6..938c8b5d1e5 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectAfterJava.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectAfterJava.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion // FILE: 1.kt diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectsOrder.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectsOrder.kt index 2bb2114e912..b53e288c787 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectsOrder.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectsOrder.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_VARIABLE open class A { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/innerClasses.fir.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/innerClasses.fir.kt index 47e0138e40b..bb39f281ff2 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/innerClasses.fir.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/innerClasses.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion open class A { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/innerClasses.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/innerClasses.kt index ac5937feaf9..6a2c7dafb62 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/innerClasses.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/innerClasses.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion open class A { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/kt3856.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/kt3856.kt index 4b18919d89b..6bbbe9e7a7b 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/kt3856.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/kt3856.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL fun foo(init: A.() -> Unit) { } diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/methodsPriority.fir.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/methodsPriority.fir.kt index 94f927ff1c2..354c3837114 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/methodsPriority.fir.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/methodsPriority.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_VARIABLE // FILE: A.java public class A { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/methodsPriority.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/methodsPriority.kt index e5638ff3996..fd5a9333ffe 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/methodsPriority.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/methodsPriority.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_VARIABLE // FILE: A.java public class A { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClass.fir.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClass.fir.kt index 751f357054c..1064e00728e 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClass.fir.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClass.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion open class A { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClass.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClass.kt index ce2b9501c08..19f430b70bb 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClass.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClass.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion open class A { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNested.fir.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNested.fir.kt index e382ae02d06..5be911607d0 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNested.fir.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNested.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion open class A { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNested.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNested.kt index 06f87294f86..0bdf9d4097d 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNested.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNested.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion open class A { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNestedJava.fir.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNestedJava.fir.kt index 9e87dcdd09f..7aec925a67e 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNestedJava.fir.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNestedJava.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion // FILE: 1.kt diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNestedJava.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNestedJava.kt index 5505b72e294..6bf62d58196 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNestedJava.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNestedJava.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion // FILE: 1.kt diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedFromJava.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedFromJava.kt index 5f8d4720f80..f36f194f5fa 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedFromJava.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedFromJava.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // FILE: A.java public interface A { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedFromJavaAfterKotlin.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedFromJavaAfterKotlin.kt index 341a0373e4b..fb9cefe729f 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedFromJavaAfterKotlin.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedFromJavaAfterKotlin.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // FILE: A.java public interface A { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedVsToplevelClass.fir.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedVsToplevelClass.fir.kt index 0b16bda987e..c9d0ceff7bc 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedVsToplevelClass.fir.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedVsToplevelClass.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion class X { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedVsToplevelClass.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedVsToplevelClass.kt index ff9a4fff2c5..76a681cbdad 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedVsToplevelClass.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedVsToplevelClass.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion class X { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/severalCompanions.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/severalCompanions.kt index 8a0d4c0825e..512907310b8 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/severalCompanions.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/severalCompanions.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_VARIABLE open class A { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClassJKJ_after.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClassJKJ_after.kt index 1294736d778..3eace147d9f 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClassJKJ_after.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClassJKJ_after.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion // FILE: J.java diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClassJKJ_before.fir.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClassJKJ_before.fir.kt index 8064c385460..ad441312b74 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClassJKJ_before.fir.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClassJKJ_before.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion // FILE: J.java public class J { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClassJKJ_before.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClassJKJ_before.kt index 24cd81e05a7..2b6a908bb02 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClassJKJ_before.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClassJKJ_before.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion // FILE: J.java public class J { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClass_after.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClass_after.kt index bb3107c73b3..101f3374357 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClass_after.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClass_after.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion // FILE: J.java diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClass_before.fir.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClass_before.fir.kt index 28daf2d8470..a2f863dceb8 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClass_before.fir.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClass_before.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion // FILE: J.java public class J { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClass_before.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClass_before.kt index b0ae1b726b9..46a216ca111 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClass_before.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClass_before.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion // FILE: J.java public class J { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_after.fir.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_after.fir.kt index 3d9630ec372..436406abc17 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_after.fir.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_after.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion // !DIAGNOSTICS: -UNUSED_VARIABLE diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_after.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_after.kt index e35db78959c..bfd636a5c33 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_after.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_after.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion // !DIAGNOSTICS: -UNUSED_VARIABLE diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_before.fir.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_before.fir.kt index 3e7feacf559..b2a4131d6dd 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_before.fir.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_before.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion // !DIAGNOSTICS: -UNUSED_VARIABLE diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_before.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_before.kt index 16443216653..16b8753acf2 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_before.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_before.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion // !DIAGNOSTICS: -UNUSED_VARIABLE diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJavaAfterKotlin_after.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJavaAfterKotlin_after.kt index 6abd67de807..12ba546c15f 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJavaAfterKotlin_after.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJavaAfterKotlin_after.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion // FILE: J.java diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJavaAfterKotlin_before.fir.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJavaAfterKotlin_before.fir.kt index 349331eb919..eac2533c4dc 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJavaAfterKotlin_before.fir.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJavaAfterKotlin_before.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion // FILE: J.java public class J { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJavaAfterKotlin_before.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJavaAfterKotlin_before.kt index 1f1ef98f175..e7a6ecb6996 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJavaAfterKotlin_before.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJavaAfterKotlin_before.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion // FILE: J.java public class J { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJava_after.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJava_after.kt index 68f182813d3..6073de4d135 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJava_after.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJava_after.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion // FILE: J.java diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJava_before.fir.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJava_before.fir.kt index 2e585f6aa21..3fe6dc885fb 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJava_before.fir.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJava_before.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion // FILE: J.java public class J { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJava_before.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJava_before.kt index 8332053753c..91fb25b4ed7 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJava_before.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJava_before.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion // FILE: J.java public class J { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/localVsStatic.fir.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/localVsStatic.fir.kt index eca87ded82f..71224514f66 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/localVsStatic.fir.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/localVsStatic.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_VARIABLE // FILE: A.java public class A { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/localVsStatic.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/localVsStatic.kt index b4be8f60f25..45d0ab3bb45 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/localVsStatic.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/localVsStatic.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_VARIABLE // FILE: A.java public class A { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/overloadStatic.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/overloadStatic.kt index be92fd4c2de..7de6e9f3ba0 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/overloadStatic.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/overloadStatic.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_VARIABLE // FILE: A.java diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticFunVsImport.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticFunVsImport.kt index eaccfdd5eea..4eb337e7886 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticFunVsImport.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticFunVsImport.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_VARIABLE // FILE: A.java diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticPropertyVsImport.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticPropertyVsImport.kt index 672ee0edfa2..d2ff0119699 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticPropertyVsImport.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticPropertyVsImport.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_VARIABLE // FILE: A.java diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsCompanion.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsCompanion.kt index 999367d0d18..4ccd169f5ee 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsCompanion.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsCompanion.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_VARIABLE // FILE: A.java diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsMember.fir.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsMember.fir.kt index 434f1c18063..aa7459a822f 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsMember.fir.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsMember.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_VARIABLE // FILE: A.java public class A { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsMember.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsMember.kt index e6920274b35..18205e3ddb9 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsMember.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsMember.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_VARIABLE // FILE: A.java public class A { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsOuter.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsOuter.kt index 4b1e5f1454c..8d79fd9d34d 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsOuter.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsOuter.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // FILE: A.java public class A { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticsFromjava.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticsFromjava.kt index 0a09f5de815..0da49408fc3 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticsFromjava.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticsFromjava.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // FILE: A.java public class A { diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticsFromjavaAfterKotlin.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticsFromjavaAfterKotlin.kt index 196b52c9e89..bb67468dd81 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticsFromjavaAfterKotlin.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticsFromjavaAfterKotlin.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // FILE: A.java public class A { diff --git a/compiler/testData/diagnostics/tests/scopes/kt1244.fir.kt b/compiler/testData/diagnostics/tests/scopes/kt1244.fir.kt index ea017d6e151..2ea10199f5a 100644 --- a/compiler/testData/diagnostics/tests/scopes/kt1244.fir.kt +++ b/compiler/testData/diagnostics/tests/scopes/kt1244.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE //KT-1244 Frontend allows access to private members of other classes package kt1244 diff --git a/compiler/testData/diagnostics/tests/scopes/kt1244.kt b/compiler/testData/diagnostics/tests/scopes/kt1244.kt index cf03bb828c4..3f30fdcef09 100644 --- a/compiler/testData/diagnostics/tests/scopes/kt1244.kt +++ b/compiler/testData/diagnostics/tests/scopes/kt1244.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE //KT-1244 Frontend allows access to private members of other classes package kt1244 diff --git a/compiler/testData/diagnostics/tests/scopes/kt37.fir.kt b/compiler/testData/diagnostics/tests/scopes/kt37.fir.kt index 74f14155ed3..8f7a51cdd30 100644 --- a/compiler/testData/diagnostics/tests/scopes/kt37.fir.kt +++ b/compiler/testData/diagnostics/tests/scopes/kt37.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE //KT-37 Typechecker doesn't complain about accessing non-public property package kt37 diff --git a/compiler/testData/diagnostics/tests/scopes/kt37.kt b/compiler/testData/diagnostics/tests/scopes/kt37.kt index 4154c41f8cb..9db31545937 100644 --- a/compiler/testData/diagnostics/tests/scopes/kt37.kt +++ b/compiler/testData/diagnostics/tests/scopes/kt37.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE //KT-37 Typechecker doesn't complain about accessing non-public property package kt37 diff --git a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/complexCompanion.fir.kt b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/complexCompanion.fir.kt index 989b88c592c..2fc7e666abd 100644 --- a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/complexCompanion.fir.kt +++ b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/complexCompanion.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE open class A { protected fun foo() {} diff --git a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/complexCompanion.kt b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/complexCompanion.kt index 8adefea99ab..1f7e4849e6c 100644 --- a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/complexCompanion.kt +++ b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/complexCompanion.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE open class A { protected fun foo() {} diff --git a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructor.fir.kt b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructor.fir.kt index 1a1fc5669b5..cce9489564f 100644 --- a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructor.fir.kt +++ b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructor.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_PARAMETER open class A protected constructor(x: Int) { diff --git a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructor.kt b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructor.kt index 65fb3936ae6..1dec3b6b658 100644 --- a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructor.kt +++ b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructor.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_PARAMETER open class A protected constructor(x: Int) { diff --git a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructorJavaDifferentPackage.fir.kt b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructorJavaDifferentPackage.fir.kt index 679c584e96c..baaa2601943 100644 --- a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructorJavaDifferentPackage.fir.kt +++ b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructorJavaDifferentPackage.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_PARAMETER // FILE: abc/A.java diff --git a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructorJavaDifferentPackage.kt b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructorJavaDifferentPackage.kt index 8aaef71defa..a9d0fa6fd7a 100644 --- a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructorJavaDifferentPackage.kt +++ b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructorJavaDifferentPackage.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_PARAMETER // FILE: abc/A.java diff --git a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructorJavaSamePackage.kt b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructorJavaSamePackage.kt index 43efcd8be2f..ec5a4e58add 100644 --- a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructorJavaSamePackage.kt +++ b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructorJavaSamePackage.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_PARAMETER diff --git a/compiler/testData/diagnostics/tests/sealed/kt44316.kt b/compiler/testData/diagnostics/tests/sealed/kt44316.kt index cd55b84deb6..99a3280b968 100644 --- a/compiler/testData/diagnostics/tests/sealed/kt44316.kt +++ b/compiler/testData/diagnostics/tests/sealed/kt44316.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // KT-44316 diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/classInitializersWithoutPrimary.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/classInitializersWithoutPrimary.kt index 63d6075cb81..55de88adb18 100644 --- a/compiler/testData/diagnostics/tests/secondaryConstructors/classInitializersWithoutPrimary.kt +++ b/compiler/testData/diagnostics/tests/secondaryConstructors/classInitializersWithoutPrimary.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL class A { constructor() diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/constructorInObject.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/constructorInObject.kt index 831a0f30b03..ed6351144d2 100644 --- a/compiler/testData/diagnostics/tests/secondaryConstructors/constructorInObject.kt +++ b/compiler/testData/diagnostics/tests/secondaryConstructors/constructorInObject.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL object A { constructor() diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/propertyInitializationWithPrimary.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/propertyInitializationWithPrimary.fir.kt index 77dbaa83059..c686905ac81 100644 --- a/compiler/testData/diagnostics/tests/secondaryConstructors/propertyInitializationWithPrimary.fir.kt +++ b/compiler/testData/diagnostics/tests/secondaryConstructors/propertyInitializationWithPrimary.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_PARAMETER class A(val w: Char) { val x: Int diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/propertyInitializationWithPrimary.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/propertyInitializationWithPrimary.kt index 3c9f5a6cfcc..f97493f1c08 100644 --- a/compiler/testData/diagnostics/tests/secondaryConstructors/propertyInitializationWithPrimary.kt +++ b/compiler/testData/diagnostics/tests/secondaryConstructors/propertyInitializationWithPrimary.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_PARAMETER class A(val w: Char) { val x: Int diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/propertyInitializationWithoutPrimary.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/propertyInitializationWithoutPrimary.kt index c2cdd885dad..83beae5e77a 100644 --- a/compiler/testData/diagnostics/tests/secondaryConstructors/propertyInitializationWithoutPrimary.kt +++ b/compiler/testData/diagnostics/tests/secondaryConstructors/propertyInitializationWithoutPrimary.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_PARAMETER class A { diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/return.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/return.fir.kt index 641a4f2f213..c70febc45ca 100644 --- a/compiler/testData/diagnostics/tests/secondaryConstructors/return.fir.kt +++ b/compiler/testData/diagnostics/tests/secondaryConstructors/return.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class A { init { return diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/return.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/return.kt index e176b17792d..b39f3968039 100644 --- a/compiler/testData/diagnostics/tests/secondaryConstructors/return.kt +++ b/compiler/testData/diagnostics/tests/secondaryConstructors/return.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class A { init { return diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/unreachableCode.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/unreachableCode.fir.kt index 0fb0ff9b8cf..918f8298c35 100644 --- a/compiler/testData/diagnostics/tests/secondaryConstructors/unreachableCode.fir.kt +++ b/compiler/testData/diagnostics/tests/secondaryConstructors/unreachableCode.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class A0 { val x: Int constructor() { diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/unreachableCode.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/unreachableCode.kt index 017c1629ce5..7d4846cfa54 100644 --- a/compiler/testData/diagnostics/tests/secondaryConstructors/unreachableCode.kt +++ b/compiler/testData/diagnostics/tests/secondaryConstructors/unreachableCode.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class A0 { val x: Int constructor() { diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/useOfPropertiesWithPrimary.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/useOfPropertiesWithPrimary.fir.kt index eb19a21c7f2..fae241ea968 100644 --- a/compiler/testData/diagnostics/tests/secondaryConstructors/useOfPropertiesWithPrimary.fir.kt +++ b/compiler/testData/diagnostics/tests/secondaryConstructors/useOfPropertiesWithPrimary.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_PARAMETER class A(val w: Int) { val x: Int diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/useOfPropertiesWithPrimary.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/useOfPropertiesWithPrimary.kt index 18b3c8d4382..163ea906412 100644 --- a/compiler/testData/diagnostics/tests/secondaryConstructors/useOfPropertiesWithPrimary.kt +++ b/compiler/testData/diagnostics/tests/secondaryConstructors/useOfPropertiesWithPrimary.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_PARAMETER class A(val w: Int) { val x: Int diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/useOfPropertiesWithoutPrimary.fir.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/useOfPropertiesWithoutPrimary.fir.kt index 82a49f19a8f..fa758add29a 100644 --- a/compiler/testData/diagnostics/tests/secondaryConstructors/useOfPropertiesWithoutPrimary.fir.kt +++ b/compiler/testData/diagnostics/tests/secondaryConstructors/useOfPropertiesWithoutPrimary.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_PARAMETER class A { val x: Int diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/useOfPropertiesWithoutPrimary.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/useOfPropertiesWithoutPrimary.kt index e5a77fbb3a8..8314cbea6e4 100644 --- a/compiler/testData/diagnostics/tests/secondaryConstructors/useOfPropertiesWithoutPrimary.kt +++ b/compiler/testData/diagnostics/tests/secondaryConstructors/useOfPropertiesWithoutPrimary.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_PARAMETER class A { val x: Int diff --git a/compiler/testData/diagnostics/tests/smartCasts/openInSealed.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/openInSealed.fir.kt index 70a19484fba..5c861e65c59 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/openInSealed.fir.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/openInSealed.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE sealed class My(open val x: Int?) { init { if (x != null) { diff --git a/compiler/testData/diagnostics/tests/smartCasts/openInSealed.kt b/compiler/testData/diagnostics/tests/smartCasts/openInSealed.kt index 6579e10bc71..08206332002 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/openInSealed.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/openInSealed.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE sealed class My(open val x: Int?) { init { if (x != null) { diff --git a/compiler/testData/diagnostics/tests/smartCasts/unstableToStable.kt b/compiler/testData/diagnostics/tests/smartCasts/unstableToStable.kt index 5216bc63586..dd707cca659 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/unstableToStable.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/unstableToStable.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL class Foo(var x: Int?) { init { diff --git a/compiler/testData/diagnostics/tests/smartCasts/unstableToStableTypes.kt b/compiler/testData/diagnostics/tests/smartCasts/unstableToStableTypes.kt index 1a872d2f169..92becd66a4b 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/unstableToStableTypes.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/unstableToStableTypes.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL class Bar { fun bar() {} diff --git a/compiler/testData/diagnostics/tests/smartCasts/varChangedInInitializer.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/varChangedInInitializer.fir.kt index 6ca3b6fbe3e..8719fd7eb4e 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varChangedInInitializer.fir.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/varChangedInInitializer.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class My { init { var y: Int? diff --git a/compiler/testData/diagnostics/tests/smartCasts/varChangedInInitializer.kt b/compiler/testData/diagnostics/tests/smartCasts/varChangedInInitializer.kt index 957538072bb..8fba905bd52 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varChangedInInitializer.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/varChangedInInitializer.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class My { init { var y: Int? diff --git a/compiler/testData/diagnostics/tests/smartCasts/varInInitNoPrimary.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/varInInitNoPrimary.fir.kt index 3b0d1ea61cb..e77139c24b3 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varInInitNoPrimary.fir.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/varInInitNoPrimary.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class Your { init { var y: String? = "xyz" diff --git a/compiler/testData/diagnostics/tests/smartCasts/varInInitNoPrimary.kt b/compiler/testData/diagnostics/tests/smartCasts/varInInitNoPrimary.kt index 4f7e1c2cad4..c1078e0fd42 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varInInitNoPrimary.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/varInInitNoPrimary.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class Your { init { var y: String? = "xyz" diff --git a/compiler/testData/diagnostics/tests/smartCasts/varInInitializer.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/varInInitializer.fir.kt index 9db530e6266..ff5328b96e4 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varInInitializer.fir.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/varInInitializer.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class My { val x: Int init { diff --git a/compiler/testData/diagnostics/tests/smartCasts/varInInitializer.kt b/compiler/testData/diagnostics/tests/smartCasts/varInInitializer.kt index 24713f425bc..bb34ebb47cf 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varInInitializer.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/varInInitializer.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class My { val x: Int init { diff --git a/compiler/testData/diagnostics/tests/subtyping/memberAnonymousObjects.fir.kt b/compiler/testData/diagnostics/tests/subtyping/memberAnonymousObjects.fir.kt index 8ecc2315fab..053e42a98a2 100644 --- a/compiler/testData/diagnostics/tests/subtyping/memberAnonymousObjects.fir.kt +++ b/compiler/testData/diagnostics/tests/subtyping/memberAnonymousObjects.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class Test { private var x = object {}; init { diff --git a/compiler/testData/diagnostics/tests/subtyping/memberAnonymousObjects.kt b/compiler/testData/diagnostics/tests/subtyping/memberAnonymousObjects.kt index df1e27c5d93..e088474c99b 100644 --- a/compiler/testData/diagnostics/tests/subtyping/memberAnonymousObjects.kt +++ b/compiler/testData/diagnostics/tests/subtyping/memberAnonymousObjects.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE class Test { private var x = object {}; init { diff --git a/compiler/testData/diagnostics/tests/testsWithJava17/jvmRecord/irrelevantFields.fir.kt b/compiler/testData/diagnostics/tests/testsWithJava17/jvmRecord/irrelevantFields.fir.kt index 41c04e6be89..0b16d255ab1 100644 --- a/compiler/testData/diagnostics/tests/testsWithJava17/jvmRecord/irrelevantFields.fir.kt +++ b/compiler/testData/diagnostics/tests/testsWithJava17/jvmRecord/irrelevantFields.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_DISABLE_LAZY_RESOLVE_CHECKS // !API_VERSION: 1.5 // !LANGUAGE: +JvmRecordSupport diff --git a/compiler/testData/diagnostics/tests/testsWithJava17/jvmRecord/irrelevantFields.kt b/compiler/testData/diagnostics/tests/testsWithJava17/jvmRecord/irrelevantFields.kt index 4bb6f0f1310..b8661930f4d 100644 --- a/compiler/testData/diagnostics/tests/testsWithJava17/jvmRecord/irrelevantFields.kt +++ b/compiler/testData/diagnostics/tests/testsWithJava17/jvmRecord/irrelevantFields.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_DISABLE_LAZY_RESOLVE_CHECKS // !API_VERSION: 1.5 // !LANGUAGE: +JvmRecordSupport diff --git a/compiler/testData/diagnostics/tests/typeParameters/kt46186.fir.kt b/compiler/testData/diagnostics/tests/typeParameters/kt46186.fir.kt index 20a9e1bba95..9c383c9c0da 100644 --- a/compiler/testData/diagnostics/tests/typeParameters/kt46186.fir.kt +++ b/compiler/testData/diagnostics/tests/typeParameters/kt46186.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -FINAL_UPPER_BOUND -CAST_NEVER_SUCCEEDS // !LANGUAGE: -AllowEmptyIntersectionsInResultTypeResolver diff --git a/compiler/testData/diagnostics/tests/typeParameters/kt46186.kt b/compiler/testData/diagnostics/tests/typeParameters/kt46186.kt index 09b059945f9..d57b9bf2b88 100644 --- a/compiler/testData/diagnostics/tests/typeParameters/kt46186.kt +++ b/compiler/testData/diagnostics/tests/typeParameters/kt46186.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -FINAL_UPPER_BOUND -CAST_NEVER_SUCCEEDS // !LANGUAGE: -AllowEmptyIntersectionsInResultTypeResolver diff --git a/compiler/testData/diagnostics/tests/typeParameters/kt46186withEmptyIntersections.kt b/compiler/testData/diagnostics/tests/typeParameters/kt46186withEmptyIntersections.kt index 9e18f1fd557..b0664951d46 100644 --- a/compiler/testData/diagnostics/tests/typeParameters/kt46186withEmptyIntersections.kt +++ b/compiler/testData/diagnostics/tests/typeParameters/kt46186withEmptyIntersections.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !DIAGNOSTICS: -FINAL_UPPER_BOUND -CAST_NEVER_SUCCEEDS // !LANGUAGE: +AllowEmptyIntersectionsInResultTypeResolver diff --git a/compiler/testData/diagnostics/tests/typealias/importFromTypeAliasObject.kt b/compiler/testData/diagnostics/tests/typealias/importFromTypeAliasObject.kt index eb29413f66a..2ee4491434e 100644 --- a/compiler/testData/diagnostics/tests/typealias/importFromTypeAliasObject.kt +++ b/compiler/testData/diagnostics/tests/typealias/importFromTypeAliasObject.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // FILE: 1.kt package bar diff --git a/compiler/testData/diagnostics/tests/typealias/importMemberFromJavaViaAlias.kt b/compiler/testData/diagnostics/tests/typealias/importMemberFromJavaViaAlias.kt index 8c4115c85b5..af1f0857e70 100644 --- a/compiler/testData/diagnostics/tests/typealias/importMemberFromJavaViaAlias.kt +++ b/compiler/testData/diagnostics/tests/typealias/importMemberFromJavaViaAlias.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_PARAMETER // SKIP_JAVAC diff --git a/compiler/testData/diagnostics/tests/typealias/starImportOnTypeAlias.fir.kt b/compiler/testData/diagnostics/tests/typealias/starImportOnTypeAlias.fir.kt index ea3d6ab50cc..19d363d89e0 100644 --- a/compiler/testData/diagnostics/tests/typealias/starImportOnTypeAlias.fir.kt +++ b/compiler/testData/diagnostics/tests/typealias/starImportOnTypeAlias.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FILE: foo.kt package test diff --git a/compiler/testData/diagnostics/tests/typealias/starImportOnTypeAlias.kt b/compiler/testData/diagnostics/tests/typealias/starImportOnTypeAlias.kt index 02ae714f6e2..9ffcdd63723 100644 --- a/compiler/testData/diagnostics/tests/typealias/starImportOnTypeAlias.kt +++ b/compiler/testData/diagnostics/tests/typealias/starImportOnTypeAlias.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FILE: foo.kt package test diff --git a/compiler/testData/diagnostics/tests/typealias/typeAliasAsBareType.fir.kt b/compiler/testData/diagnostics/tests/typealias/typeAliasAsBareType.fir.kt index ce0dceabb07..e488522d774 100644 --- a/compiler/testData/diagnostics/tests/typealias/typeAliasAsBareType.fir.kt +++ b/compiler/testData/diagnostics/tests/typealias/typeAliasAsBareType.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER -TOPLEVEL_TYPEALIASES_ONLY typealias L = List diff --git a/compiler/testData/diagnostics/tests/typealias/typeAliasAsBareType.kt b/compiler/testData/diagnostics/tests/typealias/typeAliasAsBareType.kt index 28a30c4006a..954e5bbb2cc 100644 --- a/compiler/testData/diagnostics/tests/typealias/typeAliasAsBareType.kt +++ b/compiler/testData/diagnostics/tests/typealias/typeAliasAsBareType.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER -TOPLEVEL_TYPEALIASES_ONLY typealias L = List diff --git a/compiler/testData/diagnostics/tests/valueClasses/annotations.kt b/compiler/testData/diagnostics/tests/valueClasses/annotations.kt index eeb5759e158..af6bdfd4852 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/annotations.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/annotations.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: +ValueClasses // WITH_STDLIB // SKIP_TXT diff --git a/compiler/testData/diagnostics/tests/valueClasses/presenceOfInitializerBlockInsideValueClass.kt b/compiler/testData/diagnostics/tests/valueClasses/presenceOfInitializerBlockInsideValueClass.kt index a3e1ec29e8d..3afc3e54c84 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/presenceOfInitializerBlockInsideValueClass.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/presenceOfInitializerBlockInsideValueClass.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !SKIP_JAVAC // FIR_IDENTICAL diff --git a/compiler/testData/diagnostics/tests/varargs/kt1838-param.kt b/compiler/testData/diagnostics/tests/varargs/kt1838-param.kt index bf6aed051fc..faf83f77a78 100644 --- a/compiler/testData/diagnostics/tests/varargs/kt1838-param.kt +++ b/compiler/testData/diagnostics/tests/varargs/kt1838-param.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL class A(vararg t : Int) { init { diff --git a/compiler/testData/diagnostics/tests/varargs/kt1838-val.kt b/compiler/testData/diagnostics/tests/varargs/kt1838-val.kt index 98f793456f4..3c8ddd97e1b 100644 --- a/compiler/testData/diagnostics/tests/varargs/kt1838-val.kt +++ b/compiler/testData/diagnostics/tests/varargs/kt1838-val.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL class A(vararg val t : Int) { init { diff --git a/compiler/testData/diagnostics/tests/variance/privateToThis/FunctionCall.fir.kt b/compiler/testData/diagnostics/tests/variance/privateToThis/FunctionCall.fir.kt index b04690f6481..e144342570d 100644 --- a/compiler/testData/diagnostics/tests/variance/privateToThis/FunctionCall.fir.kt +++ b/compiler/testData/diagnostics/tests/variance/privateToThis/FunctionCall.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE fun getT(): T = null!! class Test { diff --git a/compiler/testData/diagnostics/tests/variance/privateToThis/FunctionCall.kt b/compiler/testData/diagnostics/tests/variance/privateToThis/FunctionCall.kt index 877764454d2..ff413edf3aa 100644 --- a/compiler/testData/diagnostics/tests/variance/privateToThis/FunctionCall.kt +++ b/compiler/testData/diagnostics/tests/variance/privateToThis/FunctionCall.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE fun getT(): T = null!! class Test { diff --git a/compiler/testData/diagnostics/tests/variance/privateToThis/GetVal.fir.kt b/compiler/testData/diagnostics/tests/variance/privateToThis/GetVal.fir.kt index 61622ca5eba..966fb6a2ee9 100644 --- a/compiler/testData/diagnostics/tests/variance/privateToThis/GetVal.fir.kt +++ b/compiler/testData/diagnostics/tests/variance/privateToThis/GetVal.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE fun getT(): T = null!! class Test { diff --git a/compiler/testData/diagnostics/tests/variance/privateToThis/GetVal.kt b/compiler/testData/diagnostics/tests/variance/privateToThis/GetVal.kt index 51aa6dd34ee..cf8ae91cda6 100644 --- a/compiler/testData/diagnostics/tests/variance/privateToThis/GetVal.kt +++ b/compiler/testData/diagnostics/tests/variance/privateToThis/GetVal.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE fun getT(): T = null!! class Test { diff --git a/compiler/testData/diagnostics/tests/variance/privateToThis/SetVar.fir.kt b/compiler/testData/diagnostics/tests/variance/privateToThis/SetVar.fir.kt index f2176354448..a8a731f8a46 100644 --- a/compiler/testData/diagnostics/tests/variance/privateToThis/SetVar.fir.kt +++ b/compiler/testData/diagnostics/tests/variance/privateToThis/SetVar.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE fun getT(): T = null!! class Test { diff --git a/compiler/testData/diagnostics/tests/variance/privateToThis/SetVar.kt b/compiler/testData/diagnostics/tests/variance/privateToThis/SetVar.kt index 35a199d2403..b9cf5071f44 100644 --- a/compiler/testData/diagnostics/tests/variance/privateToThis/SetVar.kt +++ b/compiler/testData/diagnostics/tests/variance/privateToThis/SetVar.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE fun getT(): T = null!! class Test { diff --git a/compiler/testData/diagnostics/tests/variance/privateToThis/ValReassigned.kt b/compiler/testData/diagnostics/tests/variance/privateToThis/ValReassigned.kt index e2e6c3e92a8..bf5f28cfa7a 100644 --- a/compiler/testData/diagnostics/tests/variance/privateToThis/ValReassigned.kt +++ b/compiler/testData/diagnostics/tests/variance/privateToThis/ValReassigned.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL fun getT(): T = null!! diff --git a/compiler/testData/diagnostics/tests/when/PropertyNotInitialized.fir.kt b/compiler/testData/diagnostics/tests/when/PropertyNotInitialized.fir.kt index 5f48f19aa9a..14bde5483b8 100644 --- a/compiler/testData/diagnostics/tests/when/PropertyNotInitialized.fir.kt +++ b/compiler/testData/diagnostics/tests/when/PropertyNotInitialized.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE /* * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) * diff --git a/compiler/testData/diagnostics/tests/when/PropertyNotInitialized.kt b/compiler/testData/diagnostics/tests/when/PropertyNotInitialized.kt index 5561c8066ed..1423456d9be 100644 --- a/compiler/testData/diagnostics/tests/when/PropertyNotInitialized.kt +++ b/compiler/testData/diagnostics/tests/when/PropertyNotInitialized.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE /* * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) * diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/useOfNonConstVal.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/useOfNonConstVal.fir.kt index ae4cd577d53..d2b8f20956e 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/useOfNonConstVal.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/useOfNonConstVal.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE val nonConst = 1 const val constConst = nonConst * nonConst + 2 diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/useOfNonConstVal.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/useOfNonConstVal.kt index d09b0f4cb55..9b3252f3bc0 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/useOfNonConstVal.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/useOfNonConstVal.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE val nonConst = 1 const val constConst = nonConst * nonConst + 2 diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationTargetResolvedAmbiguously.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationTargetResolvedAmbiguously.fir.kt index 42b6cd5a77f..4a2e6078bc1 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationTargetResolvedAmbiguously.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationTargetResolvedAmbiguously.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE import kotlin.annotation.AnnotationTarget.FIELD object Some { diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationTargetResolvedAmbiguously.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationTargetResolvedAmbiguously.kt index 00c9caa488e..952fe9b828f 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationTargetResolvedAmbiguously.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationTargetResolvedAmbiguously.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE import kotlin.annotation.AnnotationTarget.FIELD object Some { diff --git a/compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce/valDefiniteInitialization.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce/valDefiniteInitialization.fir.kt index 79b8359396e..b4a7eb3a6af 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce/valDefiniteInitialization.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce/valDefiniteInitialization.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: +AllowContractsForCustomFunctions +UseCallsInPlaceEffect // !OPT_IN: kotlin.contracts.ExperimentalContracts // !DIAGNOSTICS: -INVISIBLE_REFERENCE -INVISIBLE_MEMBER diff --git a/compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce/valDefiniteInitialization.kt b/compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce/valDefiniteInitialization.kt index b91538805e4..585bfeae44a 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce/valDefiniteInitialization.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce/valDefiniteInitialization.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: +AllowContractsForCustomFunctions +UseCallsInPlaceEffect // !OPT_IN: kotlin.contracts.ExperimentalContracts // !DIAGNOSTICS: -INVISIBLE_REFERENCE -INVISIBLE_MEMBER diff --git a/compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/contractCallSites.1.4.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/contractCallSites.1.4.fir.kt index 8b4e49087a7..7a17bec7dc9 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/contractCallSites.1.4.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/contractCallSites.1.4.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: +AllowContractsForCustomFunctions +UseReturnsEffect +AllowContractsForNonOverridableMembers +AllowReifiedGenericsInContracts // !OPT_IN: kotlin.contracts.ExperimentalContracts // !DIAGNOSTICS: -INVISIBLE_REFERENCE -INVISIBLE_MEMBER -NOTHING_TO_INLINE -ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS -ABSTRACT_FUNCTION_WITH_BODY -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_FEATURE_WARNING diff --git a/compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/contractCallSites.1.4.kt b/compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/contractCallSites.1.4.kt index 1ed58c63986..45248fdbde3 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/contractCallSites.1.4.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/contractCallSites.1.4.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: +AllowContractsForCustomFunctions +UseReturnsEffect +AllowContractsForNonOverridableMembers +AllowReifiedGenericsInContracts // !OPT_IN: kotlin.contracts.ExperimentalContracts // !DIAGNOSTICS: -INVISIBLE_REFERENCE -INVISIBLE_MEMBER -NOTHING_TO_INLINE -ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS -ABSTRACT_FUNCTION_WITH_BODY -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_FEATURE_WARNING diff --git a/compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/rewriteAtSliceFunctor.kt b/compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/rewriteAtSliceFunctor.kt index e699a339bf7..119cb1928e7 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/rewriteAtSliceFunctor.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/rewriteAtSliceFunctor.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // See KT-28847 diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/illegalSuspendCalls.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/illegalSuspendCalls.kt index 4f907a2731c..5f5451466ca 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/illegalSuspendCalls.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/illegalSuspendCalls.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL import Host.bar diff --git a/compiler/testData/diagnostics/testsWithStdLib/exitProcess.kt b/compiler/testData/diagnostics/testsWithStdLib/exitProcess.kt index e103caf148d..35e273c032b 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/exitProcess.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/exitProcess.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL import java.io.File import kotlin.system.exitProcess diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/subclassOptInInheritance.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/subclassOptInInheritance.kt index 2405c5c0ec8..5c191ff5f08 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/subclassOptInInheritance.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/experimental/subclassOptInInheritance.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL @RequiresOptIn annotation class Marker diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalTargets.kt b/compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalTargets.kt index de73a03df6a..0838864f424 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalTargets.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalTargets.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !OPT_IN: kotlin.RequiresOptIn // !DIAGNOSTICS: -UNUSED_PARAMETER diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/rerunStagesAfterFixationInPartialMode.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/rerunStagesAfterFixationInPartialMode.kt index 64d4b84132b..e5f8bbdaced 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/rerunStagesAfterFixationInPartialMode.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/rerunStagesAfterFixationInPartialMode.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_PARAMETER diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/delegates/kt50994.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/delegates/kt50994.fir.kt index 88b67ef10c0..f8ec9dae3e9 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/delegates/kt50994.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/delegates/kt50994.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_DUMP // WITH_REFLECT diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/delegates/kt50994.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/delegates/kt50994.kt index 0bb5bcd6966..11f8d77f6c1 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/delegates/kt50994.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/delegates/kt50994.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_DUMP // WITH_REFLECT diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/kt32345.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/kt32345.fir.kt index 2de407aaef6..7855582e886 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/kt32345.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/kt32345.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_VARIABLE import kotlin.reflect.KProperty diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/kt32345.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/kt32345.kt index 16c6f507053..cbd2e0f0482 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/kt32345.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/kt32345.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_VARIABLE import kotlin.reflect.KProperty diff --git a/compiler/testData/diagnostics/testsWithStdLib/kt9078.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/kt9078.fir.kt index 27ba075a9ad..3894f4f527c 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/kt9078.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/kt9078.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // KT-9078 (NPE in control flow analysis); EA-71535 abstract class KFunctionKt9005WorkAround(private val _functionInstance: Function) { private val _reflectedFunction: kotlin.reflect.KFunction = _functionInstance.reflect() ?: throw IllegalStateException("") diff --git a/compiler/testData/diagnostics/testsWithStdLib/kt9078.kt b/compiler/testData/diagnostics/testsWithStdLib/kt9078.kt index 968b1e39f01..1f5949363f5 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/kt9078.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/kt9078.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // KT-9078 (NPE in control flow analysis); EA-71535 abstract class KFunctionKt9005WorkAround(private val _functionInstance: Function) { private val _reflectedFunction: kotlin.reflect.KFunction = _functionInstance.reflect() ?: throw IllegalStateException("") diff --git a/compiler/testData/diagnostics/testsWithStdLib/resolve/hidesMembers.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/resolve/hidesMembers.fir.kt index aadc9fb1e0f..6b2cb977742 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/resolve/hidesMembers.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/resolve/hidesMembers.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !CHECK_TYPE // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE diff --git a/compiler/testData/diagnostics/testsWithStdLib/resolve/hidesMembers.kt b/compiler/testData/diagnostics/testsWithStdLib/resolve/hidesMembers.kt index 59b728e2021..59fbf1bfe81 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/resolve/hidesMembers.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/resolve/hidesMembers.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !CHECK_TYPE // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE diff --git a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/pos/1.3.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/pos/1.3.fir.kt index 57061e8f587..776fb4ad4e6 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/pos/1.3.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/pos/1.3.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION // SKIP_TXT diff --git a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/1.1.fir.kt index 801763b10f9..2e8e436fcca 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/1.1.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/1.1.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_EXPRESSION // SKIP_TXT diff --git a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/1.2.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/1.2.fir.kt index f413295e4b8..eebd43da773 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/1.2.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/1.2.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_EXPRESSION // SKIP_TXT diff --git a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/1.3.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/1.3.fir.kt index e07181ba0ee..607c2bacc0d 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/1.3.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/1.3.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_EXPRESSION // SKIP_TXT diff --git a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/2.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/2.1.fir.kt index 7b8a86ddaef..16f32831f75 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/2.1.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/2.1.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_PARAMETER -UNRESOLVED_REFERENCE -UNREACHABLE_CODE // SKIP_TXT diff --git a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/2.2.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/2.2.fir.kt index 989bdad624d..270b220d7cd 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/2.2.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/2.2.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_PARAMETER -UNRESOLVED_REFERENCE -UNREACHABLE_CODE // SKIP_TXT diff --git a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/2.3.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/2.3.fir.kt index a0de45e0881..0e2faf2ef85 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/2.3.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/2.3.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_PARAMETER -UNRESOLVED_REFERENCE -UNREACHABLE_CODE // SKIP_TXT diff --git a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/3.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/3.1.fir.kt index 8ea60cc0f24..f86489dfba9 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/3.1.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos/3.1.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_PARAMETER -UNREACHABLE_CODE // SKIP_TXT diff --git a/compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-6/neg/2.2.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-6/neg/2.2.fir.kt index fa33372e65d..e8552ae6a70 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-6/neg/2.2.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-6/neg/2.2.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_PARAMETER -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE // SKIP_TXT diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg/5.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg/5.fir.kt index 3bc9d1af0ed..b1bfdd955ab 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg/5.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg/5.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // TESTCASE NUMBER: 1, 2 @Target(AnnotationTarget.TYPE) annotation class Ann(val x: Int) diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/neg/1.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/neg/1.fir.kt index 545bb0baedb..de28d2662c6 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/neg/1.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/neg/1.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !OPT_IN: kotlin.contracts.ExperimentalContracts // SKIP_TXT diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/neg/3.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/neg/3.fir.kt index 0aa0c8103c5..04655ecc1cf 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/neg/3.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/neg/3.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !OPT_IN: kotlin.contracts.ExperimentalContracts // SKIP_TXT diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/pos/1.kt b/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/pos/1.kt index 6ab74a7029d..4ee886d95c7 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/pos/1.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/pos/1.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // FIR_IDENTICAL // !OPT_IN: kotlin.contracts.ExperimentalContracts // SKIP_TXT diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/pos/3.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/pos/3.fir.kt index 20d2d374433..9505237d260 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/pos/3.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/pos/3.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !OPT_IN: kotlin.contracts.ExperimentalContracts // SKIP_TXT diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/6.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/6.fir.kt index a2dee8ecb31..780485cf909 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/6.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/6.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !LANGUAGE: +AllowContractsForNonOverridableMembers +AllowReifiedGenericsInContracts // !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER -UNREACHABLE_CODE -UNUSED_EXPRESSION // !OPT_IN: kotlin.contracts.ExperimentalContracts diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/1.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/1.fir.kt index e230f4012f6..defa50e5648 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/1.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/1.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_VARIABLE // SKIP_TXT // WITH_EXTENDED_CHECKERS diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/21.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/21.fir.kt index d8f71881074..3336d81175b 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/21.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/21.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_VARIABLE -UNUSED_VALUE // SKIP_TXT diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/30.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/30.fir.kt index 51b9430afb5..c96d20f1eeb 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/30.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/30.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_VARIABLE -UNUSED_VALUE // SKIP_TXT diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/1.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/1.fir.kt index f16f3f08f44..08e77977663 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/1.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/1.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_EXPRESSION // SKIP_TXT // TODO: https://youtrack.jetbrains.com/issue/KT-49862 diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/2.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/2.fir.kt index bdd3b1696a9..32c641c13ee 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/2.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/2.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_EXPRESSION // SKIP_TXT diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/3.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/3.fir.kt index 58da4fff46d..4f0f679f4ce 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/3.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/3.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_VARIABLE // SKIP_TXT // WITH_EXTENDED_CHECKERS diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/4.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/4.fir.kt index fc8cdaa6fbf..20b8b43935a 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/4.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/4.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_EXPRESSION // SKIP_TXT diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/6.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/6.fir.kt index 137ea822b22..830e0be98e7 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/6.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/6.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_VARIABLE -UNREACHABLE_CODE -CAN_BE_VAL // SKIP_TXT // WITH_EXTENDED_CHECKERS diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/61.fir.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/61.fir.kt index d617a63d04e..fab659da118 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/61.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/61.fir.kt @@ -1,3 +1,4 @@ +// IGNORE_REVERSED_RESOLVE // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -UNUSED_VALUE -VARIABLE_WITH_REDUNDANT_INITIALIZER // SKIP_TXT diff --git a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/firLowLevel.kt b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/firLowLevel.kt index 62c6a575be3..49f9df7cc4c 100644 --- a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/firLowLevel.kt +++ b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/firLowLevel.kt @@ -1,18 +1,23 @@ /* - * Copyright 2010-2021 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.analysis.api import org.jetbrains.kotlin.analysis.low.level.api.fir.* -import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostic.* -import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostic.compiler.based.AbstractLLFirDiagnosisCompilerTestDataSpecTest -import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostic.compiler.based.AbstractDiagnosisCompilerTestDataTest +import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostic.compiler.based.AbstractLLFirDiagnosticCompilerTestDataSpecTest +import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostic.AbstractDiagnosticTraversalCounterTest +import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostic.AbstractFirOutOfContentRootContextCollectionTest +import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostic.AbstractFirSourceContextCollectionTest +import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostic.compiler.based.AbstractDiagnosticCompilerTestDataTest +import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostic.compiler.based.AbstractLLFirPreresolvedReversedDiagnosticCompilerTestDataSpecTest +import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostic.compiler.based.AbstractLLFirPreresolvedReversedDiagnosticCompilerTestDataTest import org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure.AbstractOutOfContentRootFileStructureTest import org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure.AbstractSourceFileStructureTest import org.jetbrains.kotlin.analysis.low.level.api.fir.resolve.AbstractOutOfContentRootInnerDeclarationsResolvePhaseTest import org.jetbrains.kotlin.analysis.low.level.api.fir.resolve.AbstractSourceInnerDeclarationsResolvePhaseTest +import org.jetbrains.kotlin.generators.TestGroup import org.jetbrains.kotlin.generators.TestGroupSuite import org.jetbrains.kotlin.generators.util.TestGeneratorUtil import org.jetbrains.kotlin.spec.utils.GeneralConfiguration @@ -96,17 +101,25 @@ internal fun TestGroupSuite.generateFirLowLevelApiTests() { "analysis/low-level-api-fir/tests", "compiler/fir/analysis-tests/testData", ) { - testClass(suiteTestClassName = "DiagnosisCompilerTestFirTestdataTestGenerated") { + fun TestGroup.TestClass.modelInit() { model("resolve", pattern = TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME) model("resolveWithStdlib", pattern = TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME) } + + testClass(suiteTestClassName = "DiagnosticCompilerTestFirTestdataTestGenerated") { + modelInit() + } + + testClass(suiteTestClassName = "LLFirPreresolvedReversedDiagnosticCompilerFirTestDataTestGenerated") { + modelInit() + } } testGroup( "analysis/low-level-api-fir/tests", "compiler/testData", ) { - testClass(suiteTestClassName = "DiagnosisCompilerTestFE10TestdataTestGenerated") { + fun TestGroup.TestClass.modelInit() { model( "diagnostics/tests", // MPP tests are not actual for Analysis Api (IDE) infrastructure because it doesn't use IR at all, unlike MPP @@ -119,16 +132,31 @@ internal fun TestGroupSuite.generateFirLowLevelApiTests() { excludeDirs = listOf("native") ) } + + testClass(suiteTestClassName = "DiagnosticCompilerTestFE10TestdataTestGenerated") { + modelInit() + } + + testClass(suiteTestClassName = "LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated") { + modelInit() + } } - testGroup("analysis/low-level-api-fir/tests", testDataRoot = GeneralConfiguration.SPEC_TESTDATA_PATH) { - testClass(suiteTestClassName = "FirIdeSpecTestGenerated") { + fun TestGroup.TestClass.modelInit() { model( "diagnostics", excludeDirs = listOf("helpers") + detectDirsWithTestsMapFileOnly("diagnostics"), excludedPattern = CUSTOM_TEST_DATA_EXTENSION_PATTERN, ) } + + testClass(suiteTestClassName = "FirIdeSpecTestGenerated") { + modelInit() + } + + testClass(suiteTestClassName = "PreFirIdeSpecTestGenerated") { + modelInit() + } } } \ No newline at end of file